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

.gitignore

@@ -4,3 +4,4 @@
 *.hex
 *.map
 
+*.autosave

.gitmodules

@@ -1,3 +1,11 @@
 [submodule "stm-firmware/shellmatta"]
 	path = stm-firmware/shellmatta
-	url = https://git.shimatta.net/shimatta/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

@@ -98,7 +98,7 @@
     "    #Plot textbox\n",
     "    textstr = '\\n'.join((\n",
     "        r'$\\mu=%.2f$' % (mu, ),\n",
-    "        r'$\\sigma=%.3f$' % (sigma, ),\n",
+    "        r'$\\sigma=%.4f$' % (sigma, ),\n",
     "        r'$N_{Sa} =%d$' % (len(data), )))\n",
     "    props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)\n",
     "    ax.text(0.05, 0.95, textstr, transform=ax.transAxes, fontsize=14,\n",
@@ -344,10 +344,16 @@
    "outputs": [],
    "source": [
     "# Read in data\n",
-    "kilo_ohm_sampling1 = pd.read_csv(r'1000OhmSampling1ms.csv')\n",
-    "kilo_ohm_sampling2 = pd.read_csv(r'1000OhmSampling1ms_later.csv')\n",
-    "kilo_ohm_sampling2_fast = pd.read_csv(r'1000OhmSamplingTimerTriggered800ARR.csv')\n",
-    "plot_data_tuples = [(kilo_ohm_sampling1, 'Day 1 Sampling'), (kilo_ohm_sampling2, 'Day 2 sampling'), (kilo_ohm_sampling2_fast,'Day 2 sampling faster (ARR=700)')]\n"
+    "kilo_ohm_sampling1 = pd.read_csv(r'1000OhmSamplingFixedStableCircuit.csv')\n",
+    "kilo_ohm_sampling1_ht = pd.read_csv(r'1000OhmSamplingFixedStableCircuitHT.csv')\n",
+    "kilo_ohm_sampling2 = pd.read_csv(r'1000OhmSamplingFixedStableCircuitDay2.csv')\n",
+    "plot_data_tuples = [(kilo_ohm_sampling1, 'Day 1 Sampling -- Stable circuit -- RT'),\n",
+    "                    (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'1000OhmSampling-v1.2.csv'), 'Day 1 Sampling v1.2')\n",
+    "                   ]\n"
    ]
   },
   {
@@ -360,14 +366,19 @@
     "# def plot_histogram(ax, data, bin_count, title, signal_name):\n",
     "# def calculate_temp_for_df(data_frame, resistance_col_name='ext_lf_corr', temp_col_name='temp_calculated'):\n",
     "\n",
-    "fig, axes = plt.subplots(nrows=len(plot_data_tuples), ncols=2, sharex='col', figsize=(28, 16))\n",
+    "fig, axes = plt.subplots(nrows=len(plot_data_tuples), ncols=2, sharex='col', figsize=(28, 8*len(plot_data_tuples)))\n",
+    "\n",
+    "if len(plot_data_tuples) == 1:\n",
+    "    axes = [axes]\n",
     "\n",
     "for df, title in plot_data_tuples:\n",
-    "    calculate_temp_for_df(df, resistance_col_name='pt1000_res_raw_lf')\n",
+    "    calculate_temp_for_df(df, resistance_col_name='pt1000_value')\n",
     "\n",
     "for (df,title),ax in zip(plot_data_tuples, axes):\n",
-    "    plot_histogram(ax[0], df['pt1000_res_raw_lf'], 20, title, 'PT1000 Resistance')\n",
-    "    plot_histogram(ax[1], df['temp_calculated'], 20, title, 'Calculated Temperature in °C')\n",
+    "    plot_histogram(ax[0], df['pt1000_value'], 21, title, 'PT1000 Resistance')\n",
+    "    plot_histogram(ax[1], df['temp_calculated'], 21, title, 'Calculated Temperature in °C')\n",
+    "    ax[0].grid()\n",
+    "    ax[1].grid()\n",
     "\n",
     "plt.tight_layout()\n",
     "plt.show()"
@@ -379,7 +390,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "calc_temp(1097)"
+    "print(calc_temp(1000.6)-calc_temp(1000.4))\n",
+    "\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))"
    ]
   }
  ],
@@ -399,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

@@ -3,17 +3,20 @@
 #Compiler:	arm-none-eabi
 #####################################################################################
 #Add Files and Folders below#########################################################
-CFILES 	= main.c syscalls.c uart/uart.c cmsis_boot/system_stm32f4xx.c systick.c
+CFILES 	= main.c syscalls.c setup/system_stm32f4xx.c systick.c
 ASFILES = boot/startup_stm32f4xx.S
-INCLUDEPATH = -Icmsis -Iinclude
+INCLUDEPATH = -Iinclude
 
-OBJDIR = obj
-target	= reflow-controller
+OBJDIR_BASE = obj
+TARGET_BASE = reflow-controller
 LIBRARYPATH = -L. -Lmathlib
-LIBRARIES = # -larm_cortexM4lf_math
+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)
 
 ifneq ($(VERBOSE),true)
 QUIET=@
@@ -23,20 +26,73 @@ endif
 
 ##Custom Files###
 CFILES += adc-meas.c
-#TODO
+
+# 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 shellmatta/src/shellmatta_opt.c shell.c
+INCLUDEPATH += -Ishellmatta/api
+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
+
+DEBUG_DEFINES = -DDEBUGBUILD
+RELEASE_DEFINES = 
 
 ###################################################################################
-CC=arm-none-eabi-gcc
-OBJCOPY=arm-none-eabi-objcopy
-OBJDUMP=arm-none-eabi-objdump
-SIZE=arm-none-eabi-size
+ifeq ($(CROSS_COMPILE),)
+CROSS_COMPILE=arm-none-eabi-
+endif
 
-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 += -mfloat-abi=hard -mfpu=fpv4-sp-d16 -nostartfiles -O0 -g
+CFLAGS += -c -mlittle-endian -mthumb -mcpu=cortex-m4 -mthumb-interwork
+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
 
 ####################################################################################
 
@@ -45,17 +101,25 @@ 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] $@
 	$(QUIET)$(CC) $(LFLAGS) $(LIBRARYPATH) -o $@ $^ $(LIBRARIES)
 	$(QUIET)$(SIZE) $@
+	@echo "Built Version $(GIT_VER)"
 
 #Compiling
 $(OBJ):
@@ -67,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
@@ -78,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
-qtproject:
+	@echo -n "Cleaning up derived files for "
+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
@@ -92,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

@@ -1,31 +1,58 @@
-#include <adc-meas.h>
-#include <stm32f4xx.h>
-#include <core_cm4.h>
-#include <stm32-gpio-macros.h>
+/* 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/adc-meas.h>
+#include <stm32/stm32f4xx.h>
+#include <cmsis/core_cm4.h>
+#include <stm-periph/stm32-gpio-macros.h>
 #include <stdlib.h>
+#include <stm-periph/clock-enable-manager.h>
 
 static float pt1000_offset;
 static float pt1000_sens_dev;
 static bool calibration_active;
 static float filter_alpha;
 static volatile float pt1000_res_raw_lf;
-static volatile bool streaming_active;
 static volatile bool filter_ready;
-static volatile enum adc_pt1000_error pt1000_error;
-static volatile uint8_t *dma_flag_ptr = NULL;
+static volatile enum adc_pt1000_error pt1000_error = ADC_PT1000_INACTIVE;
+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;
+volatile uint32_t stream_pos;
 
 #define ADC_TO_RES(adc) ((float)(adc) / 4096.0f * 2500.0f)
 
 static inline void adc_pt1000_stop_sample_frequency_timer()
 {
 	TIM2->CR1 &= ~TIM_CR1_CEN;
-	RCC->APB1ENR &= ~RCC_APB1ENR_TIM2EN;
+	rcc_manager_disable_clock(&RCC->APB1ENR, BITMASK_TO_BITNO(RCC_APB1ENR_TIM2EN));
 }
 
 static inline void adc_pt1000_setup_sample_frequency_timer()
 {
-	RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;
+	rcc_manager_enable_clock(&RCC->APB1ENR, BITMASK_TO_BITNO(RCC_APB1ENR_TIM2EN));
 
 	/* Divide 42 MHz peripheral clock by 42 */
 	TIM2->PSC = (42UL-1UL);
@@ -43,49 +70,103 @@ 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;
-	RCC->APB2ENR &= ~RCC_APB2ENR_ADC1EN;
+
+	pt1000_error |= ADC_PT1000_INACTIVE;
+
+	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));
+}
+
+/**
+ * @brief Enable DMA Stream for ADC
+ *
+ * DMA2 Stream 0 is used. It will capture @ref ADC_PT1000_DMA_AVG_SAMPLES measurement values,
+ * delete the two most extreme values
+ * and calculate the avereage over the remaining values. This ensures, that one time errors are
+ * not included in the measurement.
+ *
+ * After that, the moving average filter is fed with the values.
+ *
+ */
+static inline void adc_pt1000_enable_dma_stream()
+{
+	/* Enable peripheral clock for DMA2 */
+	rcc_manager_enable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(RCC_AHB1ENR_DMA2EN));
+
+	/* Destination is the DMA sample buffer */
+	DMA2_Stream0->M0AR = (uint32_t)dma_sample_buffer;
+
+	/* Source is the ADC data register */
+	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;
+
+	NVIC_EnableIRQ(DMA2_Stream0_IRQn);
+
+	/* Enable the stream in Peripheral-to-Memory mode with 16 bit data and a circular destination buffer
+	 * Enable interrupt generation on transfer complete
+	 *
+	 * 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 | ((ADC_PT1000_CHANNEL  & 0x7)<<25);
+}
+
+static inline void adc_pt1000_disable_dma_stream()
+{
+	/* Disable the stream */
+	DMA2_Stream0->CR = 0;
+
+	/* Disable clock if necessary */
+	rcc_manager_disable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(RCC_AHB1ENR_DMA2EN));
+
+	/* Disable interrupt */
+	NVIC_DisableIRQ(DMA2_Stream0_IRQn);
 }
 
 void adc_pt1000_setup_meas()
 {
-	RCC->APB2ENR |= RCC_APB2ENR_ADC1EN;
-	RCC->AHB1ENR |= ADC_PT1000_PORT_RCC_MASK;
+	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;
-	ADC1->LTR = ADC_PT1000_LOWER_WATCHDOG;
+	ADC_PT1000_PERIPH->HTR = ADC_PT1000_UPPER_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_EOCIE;
-	ADC1->CR2 = ADC_CR2_EXTEN_0 | ADC_CR2_EXTSEL_2 | ADC_CR2_EXTSEL_1 | ADC_CR2_ADON;
+	ADC_PT1000_PERIPH->CR1 = ADC_CR1_OVRIE | ADC_CR1_AWDEN | ADC_CR1_AWDIE;
+	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);
-	streaming_active = false;
 	pt1000_res_raw_lf = 0.0f;
 
 	NVIC_EnableIRQ(ADC_IRQn);
 
-	RCC->AHB1ENR |= RCC_AHB1ENR_DMA2EN;
+	adc_pt1000_enable_dma_stream();
 
 	adc_pt1000_setup_sample_frequency_timer();
+
+	pt1000_error &= ~ADC_PT1000_INACTIVE;
 }
 
 void adc_pt1000_set_moving_average_filter_param(float alpha)
@@ -140,60 +221,43 @@ int adc_pt1000_get_current_resistance(float *resistance)
 		goto return_value;
 	}
 
-	if (streaming_active) {
-		ret_val = 1;
-		goto return_value;
-	}
-
 return_value:
 	return ret_val;
 }
 
-int adc_pt1000_stream_raw_value_to_memory(uint16_t *adc_array, uint32_t length, volatile uint8_t *flag_to_set)
+int adc_pt1000_stream_raw_value_to_memory(volatile float *adc_array, uint32_t length, volatile int *flag_to_set)
 {
-	static volatile uint8_t alt_flag;
-	int ret_val = 0;
+	int ret = 0;
 
-	if (!(ADC1->CR2 & ADC_CR2_ADON))
+	if (!flag_to_set)
 		return -1;
 
-	if (!adc_array || !length)
-		return -1000;
+	stream_buffer = adc_array;
+	stream_count = length;
+	stream_pos = 0U;
 
-	if (flag_to_set)
-		dma_flag_ptr = flag_to_set;
-	else
-		dma_flag_ptr = &alt_flag;
-
-	*dma_flag_ptr = 0;
-	streaming_active = true;
-
-	ADC1->CR2 &= ~ADC_CR2_ADON;
-	DMA2_Stream0->CR &= ~DMA_SxCR_EN;
-
-	DMA2_Stream0->M0AR = (uint32_t)adc_array;
-	DMA2_Stream0->PAR = (uint32_t)&ADC1->DR;
-
-	DMA2_Stream0->CR = DMA_SxCR_PL_1 | DMA_SxCR_MSIZE_0 | DMA_SxCR_PSIZE_0 | DMA_SxCR_MINC | DMA_SxCR_TCIE;
-	DMA2_Stream0->NDTR = length;
-	NVIC_EnableIRQ(DMA2_Stream0_IRQn);
-
-	DMA2_Stream0->CR |= DMA_SxCR_EN;
-	ADC1->CR2 |= ADC_CR2_ADON | ADC_CR2_DMA;
-
-	if (!flag_to_set) {
-		while(!alt_flag);
-
-		if (alt_flag < 0)
-			ret_val = -alt_flag;
+	if (adc_array) {
+		*flag_to_set = 0;
+		streaming_flag_ptr = flag_to_set;
+	} else {
+		ret = -2;
 	}
 
-	return ret_val;
+	return ret;
 }
 
-void adc_pt1000_convert_raw_value_array_to_resistance(float *resistance_dest, uint16_t *raw_source, uint32_t count)
+void adc_pt1000_convert_raw_value_array_to_resistance(float *resistance_dest, float *raw_source, uint32_t count)
 {
+	uint32_t i;
 
+	if (!resistance_dest)
+		resistance_dest = raw_source;
+
+	if (!raw_source || !count)
+		return;
+
+	for (i = 0; i < count; i++)
+		resistance_dest[i] = ADC_TO_RES(raw_source[i]);
 }
 
 enum adc_pt1000_error adc_pt1000_check_error()
@@ -203,69 +267,120 @@ enum adc_pt1000_error adc_pt1000_check_error()
 
 void adc_pt1000_clear_error()
 {
-	pt1000_error = ADC_PT1000_NO_ERR;
+	pt1000_error &= ~ADC_PT1000_OVERFLOW & ~ADC_PT1000_WATCHDOG_ERROR;
 }
 
 void adc_pt1000_disable()
 {
 	adc_pt1000_disable_adc();
 	adc_pt1000_stop_sample_frequency_timer();
+	adc_pt1000_disable_dma_stream();
+
 	filter_ready = false;
 	pt1000_res_raw_lf = 0.0f;
+	pt1000_error |= ADC_PT1000_INACTIVE;
+
+	if (streaming_flag_ptr) {
+		*streaming_flag_ptr = -3;
+		streaming_flag_ptr = NULL;
+	}
 }
 
-static inline __attribute__((optimize("O3"))) void adc_pt1000_filter(uint16_t adc_value)
+static inline __attribute__((optimize("O3"))) void adc_pt1000_filter(float adc_prefiltered_value)
 {
 	if (!filter_ready && --filter_startup_cnt <= 0)
 		filter_ready = true;
 
-	pt1000_res_raw_lf = (1-filter_alpha) * pt1000_res_raw_lf + filter_alpha * ADC_TO_RES((float)adc_value);
+	pt1000_res_raw_lf = (1.0f-filter_alpha) * pt1000_res_raw_lf + filter_alpha * ADC_TO_RES(adc_prefiltered_value);
+}
+
+static inline __attribute__((optimize("O3"))) float adc_pt1000_dma_avg_pre_filter()
+{
+	unsigned int i;
+	uint32_t sum = 0;
+	uint16_t max_val = 0U;
+	uint16_t min_val = 65535U;
+	uint16_t sample;
+
+	for (i = 0; i < ADC_PT1000_DMA_AVG_SAMPLES; i++) {
+		sample = dma_sample_buffer[i];
+
+		/* Update min and max trackers */
+		max_val = (sample > max_val ? sample : max_val);
+		min_val = (sample < min_val ? sample : min_val);
+
+		/* Sum up all values (for average) */
+		sum += sample;
+	}
+
+	/* Delete max and min vals from sum */
+	sum = sum - (uint32_t)max_val - (uint32_t)min_val;
+
+	/* Divide to get average and return */
+	return (float)sum / (float)(ADC_PT1000_DMA_AVG_SAMPLES-2);
 }
 
 void ADC_IRQHandler(void)
 {
 	uint32_t adc1_sr;
 
-	adc1_sr = ADC1->SR;
-	if (ADC1->SR & ADC_SR_EOC) {
-		ADC1->SR &= ~ADC_SR_EOC;
-		adc_pt1000_filter(ADC1->DR);
-	}
+	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 (streaming_active) {
-			streaming_active = false;
-			*dma_flag_ptr = -1;
-		}
 	}
 
 	if (adc1_sr & ADC_SR_AWD) {
-		ADC1->SR &= ~ADC_SR_AWD;
-		pt1000_error |= ADC_PT1000_WATCHDOG_ERROR;
+		ADC_PT1000_PERIPH->SR &= ~ADC_SR_AWD;
+		adc_watchdog_counter++;
+		if (adc_watchdog_counter >= ADC_PT1000_WATCHDOG_SAMPLE_COUNT)
+			pt1000_error |= ADC_PT1000_WATCHDOG_ERROR;
 	}
 }
 
+static void append_stream_buffer(float val)
+{
+	if (!stream_buffer || !streaming_flag_ptr)
+		return;
+
+	if (stream_pos < stream_count)
+		stream_buffer[stream_pos++] = val;
+
+	if (stream_pos >= stream_count) {
+		*streaming_flag_ptr = 1;
+		streaming_flag_ptr = NULL;
+	}
+
+}
+
 void DMA2_Stream0_IRQHandler()
 {
 	uint32_t lisr;
+	float adc_val;
 
 	lisr = DMA2->LISR;
 	DMA2->LIFCR = lisr;
 
 	if (lisr & DMA_LISR_TCIF0) {
-		*dma_flag_ptr = 1;
-		ADC1->CR2 &= ~ADC_CR2_DMA;
-		streaming_active = false;
+		/* Samples Transfered */
+		adc_val = adc_pt1000_dma_avg_pre_filter();
+		adc_pt1000_raw_reading_hf = adc_val;
+
+		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);
 	}
 
 	if (lisr & DMA_LISR_TEIF0) {
-		*dma_flag_ptr = -2;
-		ADC1->CR2 &= ~ADC_CR2_DMA;
-		streaming_active = false;
+		adc_pt1000_disable();
 	}
 
 }

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

@@ -0,0 +1,266 @@
+/* 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/calibration.h>
+#include <reflow-controller/adc-meas.h>
+#include <stm-periph/uart.h>
+#include <helper-macros/helper-macros.h>
+#include <arm_math.h>
+#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)
+{
+	if (!sens_deviation || !sens_corrected_offset)
+		return;
+
+	float delta_y;
+	float delta_x;
+	float sens_corr_mult;
+
+	delta_y = high_measured - low_measured;
+	delta_x = high_setpoint - low_setpoint;
+
+	sens_corr_mult = delta_x / delta_y;
+	*sens_deviation = sens_corr_mult - 1.0f;
+
+	*sens_corrected_offset = low_setpoint - low_measured * sens_corr_mult;
+}
+
+
+
+float *calibration_acquire_data_start(uint32_t count, volatile int *flag)
+{
+	int status;
+	float *stream_mem;
+
+	if (!count)
+		return NULL;
+
+	stream_mem = (float *)calloc(count, sizeof(float));
+	if (!stream_mem)
+		return stream_mem;
+
+	*flag = 0;
+	status = adc_pt1000_stream_raw_value_to_memory(stream_mem, count, flag);
+	if (status)
+		goto free_mem;
+
+
+	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, mem_array, count);
+
+	/* Do not compute std-deviation. Too imprecise
+	 * arm_std_f32(stream_mem, count, sigma);
+	 */
+	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, mem_array[i]);
+		max_val = MAX(max_val, mem_array[i]);
+	}
+
+	/* Compute maximum deviation range */
+	*max_dev = max_val - min_val;
+
+ret_free_mem:
+	free(mem_array);
+	return ret_val;
+}
+
+shellmatta_retCode_t calibration_sequence_shell_cmd(shellmatta_handle_t shell, const char *arg, uint32_t len)
+{
+	(void)arg;
+	(void)len;
+
+	/* This stores the current state of the calibration process */
+	static enum calibration_shell_state cal_state = CAL_START;
+	shellmatta_retCode_t ret_val = SHELLMATTA_BUSY;
+	uint32_t i;
+	int res;
+
+	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;
+				}
+			}
+		}
+
+		break;
+	case CAL_MEAS_RES1:
+		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, &mu, &dev);
+		/* Stay in this state until the measurements are finished */
+		if (res == 1) {
+			ret_val = SHELLMATTA_BUSY;
+			cal_state = CAL_MEAS_RES1;
+		} else if (res == 0) {
+			shellmatta_printf(shell, "R=%.2f, Noise peak-peak: %.2f\r\n", mu, dev);
+			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_CONTINUE;
+				shellmatta_printf(shell, "Insert 2000 Ohm calibration resistor and press ENTER\r\n");
+				cal_state = CAL_WAIT_RES2;
+			}
+		} else {
+			shellmatta_printf(shell, "Error in resistance measurement: %d", adc_pt1000_check_error());
+			ret_val = SHELLMATTA_OK;
+			cal_state = CAL_START;
+		}
+		break;
+	case CAL_WAIT_RES2:
+		cal_state = CAL_WAIT_RES2;
+		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_RES2;
+					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;
+				}
+			}
+		}
+
+		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

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+import pathlib
+
+license_header = """/* 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/>.
+*/
+"""
+
+project_dir = os.path.dirname(os.path.realpath(__file__))
+include_prefix = 'reflow-controller'
+module_include_dir = os.path.join(project_dir, os.path.join('include', include_prefix))
+
+if len(sys.argv) < 2:
+	print('Supply module name')
+	sys.exit()
+
+cpath = os.path.join(project_dir, sys.argv[1]+'.c')
+hfile = sys.argv[1]+'.h'
+hpath = os.path.join(module_include_dir, hfile)
+
+h_define = '__'+hfile.replace('.', '_').replace('-', '_').replace('/', '_').upper()+'__'
+
+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')
+	f.write('#ifndef %s\n' % h_define)
+	f.write('#define %s\n' % h_define)
+	f.write('\n')
+	f.write('#endif /* %s */\n' % h_define)
+	
+

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

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+import numpy as np
+
+license_header = """/* 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/>.
+*/
+
+"""
+
+hfile="temp-converter-data.h"
+
+project_dir = os.path.dirname(os.path.realpath(__file__))
+include_prefix = 'reflow-controller'
+module_include_dir = os.path.join(project_dir, os.path.join('include', include_prefix))
+include_file = os.path.join(module_include_dir, hfile)
+
+h_define = '__'+hfile.replace('.', '_').replace('-', '_').upper()+'__'
+
+min_res = 1000
+max_res = 2200
+res_step = 20
+
+R_zero = 1000.0
+A = 3.9083E-3
+B = -5.7750E-7
+
+def calc_temp(resistance):
+    temp = (-R_zero * A + np.sqrt(R_zero*R_zero * A * A - 4* R_zero * B * (R_zero - resistance)))/(2*R_zero*B)
+    return temp
+
+if ((max_res-min_res) % res_step) != 0:
+	print('Resistance range must be a multiple of res_step!')
+	sys.exit(-1)
+
+print('Calculating temperature table for %f Ohm to %f Ohm in %f Ohm steps' % (min_res, max_res, res_step))
+
+temp_array = ''
+
+for res in range(min_res, max_res+res_step, res_step):
+	temp = calc_temp(res)
+	temp_array = temp_array+ ',%.2ff' % temp
+
+temp_array = temp_array[1:]
+
+with open(include_file, 'x') as f:
+	f.write(license_header)
+	f.write('\n')
+	f.write('#ifndef %s\n' % h_define)
+	f.write('#define %s\n\n' % h_define)
+	f.write('#define TEMP_CONVERSION_ARRAY_DATA %s\n' % temp_array)
+	f.write('#define TEMP_CONVERSION_MIN_RES %d\n' % min_res)
+	f.write('#define TEMP_CONVERSION_MAX_RES %d\n' % max_res)
+	f.write('#define TEMP_CONVERSION_RES_STEP %d\n' % res_step)
+	f.write('\n')
+	f.write('#endif /* %s */\n' % h_define)

stm-firmware/digio.c

@@ -0,0 +1,194 @@
+/* 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/digio.h>
+#include <stm32/stm32f4xx.h>
+#include <stm-periph/clock-enable-manager.h>
+#include <stm-periph/stm32-gpio-macros.h>
+#include <helper-macros/helper-macros.h>
+
+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)
+{
+	DIGIO_PORT->MODER &= MODER_DELETE(bit_no);
+	switch (in_out) {
+	case 2:
+		DIGIO_PORT->MODER |= ALTFUNC(bit_no);
+		SETAF(DIGIO_PORT, bit_no, alt_func);
+		break;
+	case 1:
+		DIGIO_PORT->MODER |= OUTPUT(bit_no);
+		break;
+	case 0: /* expected fallthrough */
+	default:
+		break;
+	}
+
+}
+
+void digio_setup_default_all()
+{
+	unsigned int i;
+
+	rcc_manager_enable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(DIGIO_RCC_MASK));
+
+	for (i = 0; i < COUNT_OF(digio_pins); i++) {
+		digio_setup_pin_int(digio_pins[i], digio_default_io[i], digio_default_altfunc[i]);
+		if (digio_default_io[i] == 1)
+			digio_set(i, 0);
+	}
+}
+
+void digio_setup_pin(uint8_t num, uint8_t in_out, uint8_t alt_func)
+{
+	if (num >= COUNT_OF(digio_pins))
+		return;
+	digio_setup_pin_int(digio_pins[num], in_out, alt_func);
+}
+
+void digio_set(uint8_t num, int val)
+{
+	if (num >= COUNT_OF(digio_pins))
+		return;
+	if (val)
+		DIGIO_PORT->ODR |= (1<<digio_pins[num]);
+	else
+		DIGIO_PORT->ODR &= ~(1<<digio_pins[num]);
+}
+
+int digio_get(uint8_t num)
+{
+	if (num >= COUNT_OF(digio_pins))
+		return -1;
+
+	if ((DIGIO_PORT->MODER & (0x3<<digio_pins[num])) == OUTPUT(digio_pins[num]))
+		return (DIGIO_PORT->ODR & (1<<digio_pins[num]) ? 1 : 0);
+	else
+		return (DIGIO_PORT->IDR & (1<<digio_pins[num]) ? 1 : 0);
+}
+
+static const uint8_t led_pins[] = {LED_PINS};
+
+void led_setup()
+{
+	unsigned int i;
+
+	rcc_manager_enable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(LED_RCC_MASK));
+	for (i = 0; i < COUNT_OF(led_pins); i++) {
+		LED_PORT->MODER &= MODER_DELETE(led_pins[i]);
+		LED_PORT->MODER |= OUTPUT(led_pins[i]);
+	}
+}
+
+void led_set(uint8_t num, int val)
+{
+	if (num >= COUNT_OF(led_pins))
+		return;
+	if (val)
+		LED_PORT->ODR |= (1<<led_pins[num]);
+	else
+		LED_PORT->ODR &= ~(1<<led_pins[num]);
+}
+
+int led_get(uint8_t num)
+{
+	if (num >= COUNT_OF(led_pins))
+		return -1;
+
+	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));
+
+	LOUDSPEAKER_PORT->MODER &= MODER_DELETE(LOUDSPEAKER_PIN);
+	LOUDSPEAKER_PORT->MODER |= OUTPUT(LOUDSPEAKER_PIN);
+
+	loudspeaker_freq_timer_init();
+	loudspeaker_set(0U);
+}
+
+static void loudspeaker_start_beep(uint16_t val)
+{
+#if LOUDSPEAKER_MULTIFREQ
+	TIM7->ARR = val;
+	TIM7->CNT = 0UL;
+	TIM7->CR1 |= TIM_CR1_CEN;
+#else
+	(void)val;
+	LOUDSPEAKER_PORT->ODR |= (1<<LOUDSPEAKER_PIN);
+#endif
+}
+
+static void loudspeaker_stop_beep(void)
+{
+#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/doxygen/build-doxygen.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+SOURCE="${BASH_SOURCE[0]}"
+while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
+  DIR="$( cd -P "$( dirname "$SOURCE" )" >/dev/null && pwd )"
+  SOURCE="$(readlink "$SOURCE")"
+  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE" # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
+done
+DIR="$( cd -P "$( dirname "$SOURCE" )" >/dev/null && pwd )"
+cd "$DIR"
+
+export PROJECT_NUMBER=`git describe --always --tags --dirty`
+
+if [ $# != 1 ]; then
+	export OUTPUT_DIRECTORY="./output"
+else
+	export OUTPUT_DIRECTORY="$1"
+fi
+
+doxygen Doxyconfig

stm-firmware/doxygen/output/.gitignore

@@ -0,0 +1,3 @@
+*
+*/
+!.gitignore

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/arm_math.h

@@ -267,7 +267,7 @@
 #define __CMSIS_GENERIC         /* disable NVIC and Systick functions */
 
 #if defined (ARM_MATH_CM4)
-#include "core_cm4.h"
+#include <cmsis/core_cm4.h>
 #elif defined (ARM_MATH_CM3)
 #include "core_cm3.h"
 #elif defined (ARM_MATH_CM0)
@@ -282,8 +282,8 @@
 #endif
 
 #undef  __CMSIS_GENERIC         /* enable NVIC and Systick functions */
-#include "string.h"
-#include "math.h"
+#include <string.h>
+#include <math.h>
 #ifdef	__cplusplus
 extern "C"
 {

stm-firmware/include/cmsis/core_cm4.h

@@ -151,9 +151,9 @@
 #endif
 
 #include <stdint.h>                      /* standard types definitions                      */
-#include <core_cmInstr.h>                /* Core Instruction Access                         */
-#include <core_cmFunc.h>                 /* Core Function Access                            */
-#include <core_cm4_simd.h>               /* Compiler specific SIMD Intrinsics               */
+#include <cmsis/core_cmInstr.h>                /* Core Instruction Access                         */
+#include <cmsis/core_cmFunc.h>                 /* Core Function Access                            */
+#include <cmsis/core_cm4_simd.h>               /* Compiler specific SIMD Intrinsics               */
 
 #endif /* __CORE_CM4_H_GENERIC */
 

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/helper-macros/helper-macros.h

@@ -0,0 +1,39 @@
+/* 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 __HELPER_MACROS_H__
+#define __HELPER_MACROS_H__
+
+#include <stddef.h>
+
+#define xstr(x) str(x)
+#define str(x) #x
+
+#define CONCATX(x,y) CONCAT(x,y)
+#define CONCAT(x,y) x##y
+
+#define COUNT_OF(x) ((sizeof(x)/sizeof(0[x])) / ((size_t)(!(sizeof(x) % sizeof(0[x])))))
+
+#define MIN(a,b) (((a) < (b)) ? (a) : (b))
+#define MAX(a,b) (((a) > (b)) ? (a) : (b))
+
+#define ABS(a) ((a) < 0 ? (-1*(a)) : (a))
+
+#endif /* __HELPER_MACROS_H__ */

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

@@ -1,9 +1,34 @@
+/* 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 __ADCMEAS_H__
 #define __ADCMEAS_H__
 
 #include <stdbool.h>
 #include <stdint.h>
-#include <stm32f4xx.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
  */
@@ -12,32 +37,60 @@
 /**
  * @brief ADC channel number of PT1000 sensor input
  */
-#define ADC_PT1000_CHANNEL 2
+#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
 
-#define ADC_PT1000_PIN 2
+/**
+ * @brief The GPIO pin number the PT1000 analog voltage is connected to
+ */
+#define ADC_PT1000_PIN 2U
 
-#define ADC_FILTER_STARTUP_CYCLES 800
+/**
+ * @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
 
-#define ADC_PT1000_SAMPLE_CNT_DELAY 2000
+/**
+ * @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
 
 /**
  * @brief Lower value for valid input range for PT1000 measurement
  *
  * If the input of the PT1000 sensor is below this value, an error is thrown. This is used to disable the temperature control loop
  */
-#define ADC_PT1000_LOWER_WATCHDOG 100
+#define ADC_PT1000_LOWER_WATCHDOG 200U
 
 /**
  * @brief Upper value for valid input range for PT1000 measurement
  *
  * If the input of the PT1000 sensor is above this value, an error is thrown. This is used to disable the temperature control loop
  */
-#define ADC_PT1000_UPPER_WATCHDOG 4000
+#define ADC_PT1000_UPPER_WATCHDOG 4000U
 
-enum adc_pt1000_error {ADC_PT1000_NO_ERR= 0, ADC_PT1000_WATCHDOG_ERROR=(1UL<<0), ADC_PT1000_OVERFLOW=(1UL<<1)};
+/**
+ * @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)};
 
 /**
  * @brief This function sets up the ADC measurement fo the external PT1000 temperature sensor
@@ -85,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
@@ -100,18 +153,14 @@ int adc_pt1000_get_current_resistance(float *resistance);
 
 /**
  * @brief Stream the raw ADC data to an array in memory.
- *
- * Streaming is done using DMA2 Stream0.
- * This function is used for gathering fullspeed sampling data for external interfaces or calibration
- *
  * @param adc_array Array to stream data to
  * @param length Amount of data points to be measured
  * @param flag_to_set This flag is set to 1 once the data has been measured and is transferred. A negative value indicates an error
  * @return 0 if measurement could be started
  */
-int adc_pt1000_stream_raw_value_to_memory(uint16_t *adc_array, uint32_t length, volatile uint8_t *flag_to_set);
+int adc_pt1000_stream_raw_value_to_memory(volatile float *adc_array, uint32_t length, volatile int *flag_to_set);
 
-void adc_pt1000_convert_raw_value_array_to_resistance(float *resistance_dest, uint16_t *raw_source, uint32_t count);
+void adc_pt1000_convert_raw_value_array_to_resistance(float *resistance_dest, float *raw_source, uint32_t count);
 
 /**
  * @brief Check if the ADC measurement experienced any kind of error (DMA, Analog Watchdog, etc...)
@@ -120,8 +169,14 @@ void adc_pt1000_convert_raw_value_array_to_resistance(float *resistance_dest, ui
  */
 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

@@ -0,0 +1,36 @@
+/* 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 __CALIBRATION_H__
+#define __CALIBRATION_H__
+
+#define CALIBRATION_MAX_PEAK_PEAK_NOISE_OHM 8.0f
+
+#include <stdint.h>
+#include <shellmatta.h>
+
+void calibration_calculate(float low_measured, float low_setpoint, float high_measured, float high_setpoint,
+			   float *sens_deviation, float *sens_corrected_offset);
+
+float *calibration_acquire_data_start(uint32_t count, volatile int *flag);
+
+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

@@ -0,0 +1,68 @@
+/* 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 __DIGIO_H__
+#define __DIGIO_H__
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <helper-macros/helper-macros.h>
+
+#define DIGIO_PORT GPIOB
+#define DIGIO_RCC_MASK RCC_AHB1ENR_GPIOBEN
+#define DIGIO_PINS 4,5,6,7
+
+#ifdef DEBUGBUILD
+#define DIGIO_INOUT_DEFAULT 0,0,0,0
+#define DIGIO_ALTFUNC_DEFAULT 0,0,0,0
+#else
+#define DIGIO_INOUT_DEFAULT 0,0,2,2
+#define DIGIO_ALTFUNC_DEFAULT 0,0,7,7
+#endif
+
+#define BEEPER_PORT GPIOB
+#define BEEPER_RCC_MASK RCC_AHB1ENR_GPIOBEN
+
+
+void digio_setup_default_all();
+
+void digio_setup_pin(uint8_t num, uint8_t in_out, uint8_t alt_func);
+void digio_set(uint8_t num, int val);
+int digio_get(uint8_t num);
+
+#define LED_PORT GPIOB
+#define LED_RCC_MASK RCC_AHB1ENR_GPIOBEN
+#define LED_PINS 2,3
+
+void led_setup();
+void led_set(uint8_t num, int val);
+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(uint16_t val);
+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

@@ -0,0 +1,44 @@
+/* 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 __ROTARY_ENCODER_H__
+#define __ROTARY_ENCODER_H__
+
+#include <stm32/stm32f4xx.h>
+
+#define ROTARY_ENCODER_TIMER TIM5
+#define ROTARY_ENCODER_TIMER_RCC_MASK RCC_APB1ENR_TIM5EN
+#define ROTARY_ENCODER_PIN1 0
+#define ROTARY_ENCODER_PIN2 1
+#define ROTARY_ENCODER_PORT GPIOA
+#define ROTARY_ENCODER_PORT_ALTFUNC 2
+#define ROTARY_ENCODER_RCC_MASK RCC_AHB1ENR_GPIOAEN
+
+void rotary_encoder_setup(void);
+
+uint32_t rotary_encoder_get_abs_val(void);
+
+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

@@ -0,0 +1,35 @@
+/* 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 __SHELL_H__
+#define __SHELL_H__
+
+#include <stddef.h>
+#include <shellmatta.h>
+
+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

@@ -0,0 +1,78 @@
+/* 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/>.
+ */
+
+/**
+ * @file systick.h
+ */
+
+#ifndef __SYSTICK_H__
+#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 16800, which results in a 100us tick for 168 MHz CPU speed
+ */
+#define SYSTICK_RELOAD (16800UL)
+
+/**
+ * @brief Variable used by the systick_wait_ms function
+ */
+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
+ */
+void systick_setup(void);
+
+/**
+ * @brief Wait for x milliseconds
+ *
+ * This function is not reentrant and must not be called from an interrupt
+ *
+ * @warning Do not use in interrupt context
+ * @param ms wait time in ms
+ */
+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

@@ -0,0 +1,29 @@
+/* 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 __TEMP_CONVERTER_DATA_H__
+#define __TEMP_CONVERTER_DATA_H__
+
+#define TEMP_CONVERSION_ARRAY_DATA -0.00f,5.12f,10.25f,15.39f,20.53f,25.68f,30.84f,36.01f,41.19f,46.37f,51.57f,56.77f,61.98f,67.19f,72.42f,77.65f,82.89f,88.14f,93.40f,98.67f,103.94f,109.23f,114.52f,119.82f,125.13f,130.45f,135.77f,141.11f,146.45f,151.81f,157.17f,162.54f,167.92f,173.31f,178.71f,184.11f,189.53f,194.96f,200.39f,205.84f,211.29f,216.75f,222.22f,227.71f,233.20f,238.70f,244.21f,249.73f,255.26f,260.80f,266.35f,271.91f,277.48f,283.06f,288.65f,294.25f,299.86f,305.48f,311.11f,316.75f,322.40f
+#define TEMP_CONVERSION_MIN_RES 1000
+#define TEMP_CONVERSION_MAX_RES 2200
+#define TEMP_CONVERSION_RES_STEP 20
+
+#endif /* __TEMP_CONVERTER_DATA_H__ */

stm-firmware/include/reflow-controller/temp-converter.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.
+ *
+ * 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 __TEMP_CONVERTER_H__
+#define __TEMP_CONVERTER_H__
+
+/**
+ * @brief Convert PT1000 resistance to temperature in degrees celsius
+ * @param resistance PT1000 resistance value
+ * @param[out] temp_out Temperature output
+ * @return 0 if ok, -1 if value is below conversion range, 1 if value is above conversion range,-1000 in case of pointer error
+ */
+int temp_converter_convert_resistance_to_temp(float resistance, float *temp_out);
+
+#endif /* __TEMP_CONVERTER_H__ */

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/clock-enable-manager.h

@@ -0,0 +1,68 @@
+/* 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 __CLOCK_ENABLE_MANAGER_H__
+#define __CLOCK_ENABLE_MANAGER_H__
+
+#include <stdint.h>
+#include <stm-periph/stm32-gpio-macros.h>
+
+/**
+ * @brief The RCC Enable Manager uses static memory with a fixed maximum
+ */
+#define RCC_ENABLE_MANAGER_STATIC 1U
+
+#if RCC_ENABLE_MANAGER_STATIC
+#define RCC_ENABLE_MANAGER_COUNT 30U
+#else
+#error "RCC Enable Manager not yet implemented with dynamic memory"
+#endif
+
+/**
+ * @brief Enable Clock for peripheral by setting the corresponding bit (@p bit_no) to one
+ *
+ * This function also keeps a enable count on each bit that is set, in order to allow nested enables/disables
+ *
+ * If there is no more space to track a new register bit in memory (either due to the static limit or due to no remaining heap space),
+ * the function still enables the peripheral clock but does not track it and returns -1
+ *
+ * @param rcc_enable_register
+ * @param bit_no
+ *
+ * @return 0 if successful
+ */
+int rcc_manager_enable_clock(volatile uint32_t *rcc_enable_register, uint8_t bit_no);
+
+/**
+ * @brief Disable clock for peripheral and decrement the enaböe-counter of that bit.
+ *
+ * If there is no bit entry in the counting table yet, teh peripheral clock is not disabled and error code
+ * -1 is returned.
+ *
+ * If the count reaches zero, the element is removed from the list to make room for new ones
+ *
+ * @param rcc_enable_register Register to disable the bit in
+ * @param bit_no Bit number (0 to 31) of the bit to disable
+ * @return 0 if successful
+ */
+int rcc_manager_disable_clock(volatile uint32_t *rcc_enable_register, uint8_t bit_no);
+
+
+#endif /* __CLOCK_ENABLE_MANAGER_H__ */

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

@@ -0,0 +1,162 @@
+/* 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/>.
+ */
+
+/**
+ * @file dma-ring-buffer.h
+ * @brief Header for DMA Ring buffer implemenation
+ */
+
+/**
+ * @defgroup dma-ring-buffer DMA Ring Buffers from and to Peripherals
+ */
+
+#ifndef __DMA_RING_BUFFER_H__
+#define __DMA_RING_BUFFER_H__
+
+#include <stdbool.h>
+#include <stm32/stm32f4xx.h>
+#include <stddef.h>
+
+/**
+ * @addtogroup dma-ring-buffer
+ * @{
+ */
+
+/**
+ * @brief DMA ring buffer for data transfer from peripheral to memory
+ */
+struct dma_ring_buffer_to_mem {
+	volatile void *data_ptr;			/**< @brief Ring buffer */
+	size_t buffer_count;		/**< @brief Size of buffer in multiples of elements */
+	DMA_Stream_TypeDef *dma;	/**< @brief DMA Stream used to transfer data */
+	size_t get_idx;			/**< @brief Get index for SW. Indicates the next element to be read */
+	uint8_t base_dma_id;		/**< @brief Id of the DMA controller, the stream belongs to. Either 1 or 2. */
+	size_t element_size;		/**< @brief Size of a buffer element (1, 2, or 4 bytes) */
+};
+
+/**
+ * @brief DMA ring buffer for data transfer from memory to peripheral
+ */
+struct dma_ring_buffer_to_periph {
+	volatile void *src_buffer;			/**< @brief Ring buffer */
+	size_t buffer_count;			/**< @brief Size of buffer in multiples of elements */
+	DMA_Stream_TypeDef *dma;		/**< @brief DMA Stream used to transfer data */
+	volatile size_t dma_get_idx_current;	/**< @brief Current get index of the (not yet) running DMA Stream. */
+	volatile size_t dma_get_idx_future;	/**< @brief Get index in the buffer, after the current DMA transfer has finished */
+	volatile size_t sw_put_idx;		/**< @brief Put index for software */
+	uint8_t dma_base_id;			/**< @brief Id of the DMA controller, the stream belongs to. Either 1 or 2. */
+	size_t element_size;			/**< @brief Size of a buffer element (1, 2, or 4 bytes) */
+};
+
+/**
+ * @brief Initialize a ring buffer used for transferring data from a peripheral to memory.
+ * @param[in,out] dma_buffer structure representing the newly initialized ring buffer
+ * @param base_dma_id Id of the DMA controller, the stream belongs to. Either 1 or 2
+ * @param[in] dma_stream DMA Stream to use
+ * @param buffer_element_count Size of buffer in elements
+ * @param element_size Size of an element. Either 1, 2, or 4 bytes
+ * @param[in] data_buffer Buffer to operate on
+ * @param[in] src_reg Source register to read data from
+ * @param dma_trigger_channel Trigger channel for DMA stream. Consult reference manual for a valid number.
+ * @note The ring buffers do not have an overrun detection. You have to make sure to empty the buffer in time.
+ * @return Status (0 is ok)
+ */
+int dma_ring_buffer_periph_to_mem_initialize(struct dma_ring_buffer_to_mem *dma_buffer, uint8_t base_dma_id, DMA_Stream_TypeDef *dma_stream, size_t buffer_element_count, size_t element_size, volatile void *data_buffer, void *src_reg, uint8_t dma_trigger_channel);
+
+/**
+ * @brief Get data from a peripheral to memory ring buffer
+ * @param[in] buff Ring buffer structure
+ * @param[out] data_buff Pointer to set to new data. This must not be modified!
+ * @param[out] len Length in elements
+ * @return 0 if successful, but no data), -1 if error, 1 if data, and 2 if data with wrap around. Call function again in this case to retrieve rest after wrap around.
+ */
+int dma_ring_buffer_periph_to_mem_get_data(struct dma_ring_buffer_to_mem *buff, const volatile void **data_buff, size_t *len);
+
+/**
+ * @brief Stop the ring buffer operation.
+ * @note The ring buffer loses all its configuration after this call.
+ * @param buff Ring buffer to stop
+ */
+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
+ * @param base_dma_id Id of the DMA controller, the stream belongs to. Either 1 or 2
+ * @param[in] dma_stream DMA stream to use
+ * @param buffer_element_count size of ring buffer in elements
+ * @param element_size Size of an element. Either 1, 2, or 4 bytes
+ * @param[in] data_buffer Ring buffer
+ * @param dma_trigger_channel Trigger channel to start DMA. Consult reference manual for values
+ * @param[in] dest_reg Destination register to stream data to
+ * @return 0 if successful
+ */
+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);
+
+/**
+ * @brief Insert data into the ring buffer
+ *
+ * This function will try to insert data into the ring buffer. If the buffer is full, it will wait for the buffer to become empty,
+ * until the data fits into the buffer. If the data is larger than the full buffer, it is split. The buffer is fully written. The rest is written after the buffer has emptied out,
+ * until the rest fits in
+ *
+ * @param buff Ring buffer element
+ * @param data_to_insert Data to put in buffer
+ * @param count Element count of data to insert
+ * @return 0 if successful.
+ */
+int dma_ring_buffer_mem_to_periph_insert_data(struct dma_ring_buffer_to_periph *buff, const void *data_to_insert, size_t count);
+
+/**
+ * @brief Call this function on a transfer complete interrupt of the DMA.
+ * @note It is mandatory to call this function in order to provide a working ring buffer.
+ * @param buff Ring buffer struct
+ */
+void dma_ring_buffer_mem_to_periph_int_callback(struct dma_ring_buffer_to_periph *buff);
+
+/**
+ * @brief Stop the ring buffer operation.
+ * @note The ring buffer loses all its configuration after this call.
+ * @param buff Ring buffer to stop
+ */
+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

@@ -0,0 +1,44 @@
+/* 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 __STM32GPIOMACROS_H__
+#define __STM32GPIOMACROS_H__
+
+#define MODER_DELETE(pin) ~(0x3U << ((pin) * 2))
+#define PUPDR_DELETE(pin) ~(0x3U << ((pin) * 2))
+#define OUTPUT(pin)  (0x01U << ((pin) * 2))
+#define PULLUP(pin) (0x1U << ((pin)* 2))
+#define PULLDOWN(pin) (0x2U << ((pin)* 2))
+#define ALTFUNC(pin) ((0x2) << ((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: \
+		 x&0x100?8:x&0x200?9:x&0x400?10:x&0x800?11: \
+		 x&0x1000?12:x&0x2000?13:x&0x4000?14:x&0x8000?15: \
+		 x&0x10000?16:x&0x20000?17:x&0x40000?18:x&0x80000?19: \
+		 x&0x100000?20:x&0x200000?21:x&0x400000?22:x&0x800000?23: \
+		 x&0x1000000?24:x&0x2000000?25:x&0x4000000?26:x&0x8000000?27: \
+		 x&0x10000000?28:x&0x20000000?29:x&0x40000000?30:x&0x80000000?31:32)
+
+#endif /* __STM32GPIOMACROS_H__ */

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

@@ -0,0 +1,77 @@
+/* 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/>.
+ */
+
+#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_
+
+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;
+};
+
+int uart_init(struct stm_uart *uart);
+
+void uart_change_brr(struct stm_uart *uart, uint32_t brr);
+
+void uart_disable(struct stm_uart *uart);
+
+void uart_send_char(struct stm_uart *uart, char c);
+
+void uart_send_array(struct stm_uart *uart, const char *data, uint32_t len);
+
+void uart_send_string(struct stm_uart *uart, const char *string);
+
+void uart_send_array_with_dma(struct stm_uart *uart, const char *data, uint32_t len);
+
+void uart_send_string_with_dma(struct stm_uart *uart, const char *string);
+
+int uart_receive_data_with_dma(struct stm_uart *uart, const char **data, size_t *len);
+
+char uart_get_char(struct stm_uart *uart);
+
+int uart_check_rx_avail(struct stm_uart *uart);
+
+void uart_tx_dma_complete_int_callback(struct stm_uart *uart);
+
+size_t uart_dma_tx_queue_avail(struct stm_uart *uart);
+
+size_t uart_dma_rx_queue_avail(struct stm_uart *uart);
+
+#endif /* UART_UART_H_ */

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

@@ -0,0 +1,34 @@
+/* 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 __UNIQUE_ID_H__
+#define __UNIQUE_ID_H__
+
+#include <stdint.h>
+
+/**
+ * @brief Get the device's unique 96 bit ID programmed by ST during manufacturing
+ * @param high high word of ID
+ * @param mid mid word of ID
+ * @param low low word of ID
+ */
+void unique_id_get(uint32_t *high, uint32_t *mid, uint32_t *low);
+
+#endif /* __UNIQUE_ID_H__ */

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

@@ -1,11 +0,0 @@
-#ifndef __STM32GPIOMACROS_H__
-#define __STM32GPIOMACROS_H__
-
-#define OUTPUT(pin)  (0x01U << (pin * 2))
-#define PULLUP(pin) (0x1U << (pin* 2))
-#define ALTFUNC(pin) ((0x2) << (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))
-
-#endif /* __STM32GPIOMACROS_H__ */

stm-firmware/include/stm32/stm32f407xx.h

@@ -181,8 +181,8 @@ typedef enum
   * @}
   */
 
-#include "core_cm4.h"             /* Cortex-M4 processor and core peripherals */
-#include "system_stm32f4xx.h"
+#include <cmsis/core_cm4.h>             /* Cortex-M4 processor and core peripherals */
+#include <setup/system_stm32f4xx.h>
 #include <stdint.h>
 
 /** @addtogroup Peripheral_registers_structures

stm-firmware/include/systick.h

@@ -1,43 +0,0 @@
-#ifndef __SYSTICK_H__
-#define __SYSTICK_H__
-
-#include <stdint.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
- */
-#define SYSTICK_RELOAD (168000UL)
-
-/**
- * @brief Variable used by the systick_wait_ms function
- */
-extern volatile uint32_t wait_tick_ms;
-
-/**
- * @brief Systemclock in milliseconds.
- *
- * This value must not be reset during the whole runtime.
- *
- */
-extern volatile uint64_t global_tick_ms;
-
-/**
- * @brief Setup the Systick timer to generate a 1 ms tick
- */
-void systick_setup(void);
-
-/**
- * @brief Wait for x milliseconds
- *
- * This function is not reentrant and must not be called from an interrupt
- *
- * @warning Do not use in interrupt context
- * @param ms wait time in ms
- */
-void systick_wait_ms(uint32_t ms);
-
-
-#endif /* __SYSTICK_H__ */

stm-firmware/include/uart/uart.h

@@ -1,17 +0,0 @@
-/*
- * uart.h
- *
- *  Created on: Dec 15, 2014
- *      Author: shino-chan
- */
-
-#ifndef UART_UART_H_
-#define UART_UART_H_
-
-void initUART();
-void sendChar(char c);
-void sendString(char* s, int count);
-#ifdef _P20N_
-void yuri();
-#endif
-#endif /* UART_UART_H_ */

stm-firmware/main.c

@@ -1,47 +1,278 @@
-/*
- * main.c
+/* Reflow Oven Controller
  *
- *  Created on: Apr 25, 2015
- *      Author: mari
+ * 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 <stm32f4xx.h>
-#include <systick.h>
-//#include <arm_math.h>
-#include <stm32-gpio-macros.h>
-#include <system_stm32f4xx.h>
-#include <stdlib.h>
-#include <string.h>
-#include <adc-meas.h>
 
-static void setup_nvic_priorities()
+/**
+ * @file main.c
+ * @brief Main file for firmware
+ */
+
+#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>
+#include <setup/system_stm32f4xx.h>
+#include <reflow-controller/systick.h>
+#include <reflow-controller/adc-meas.h>
+#include <reflow-controller/shell.h>
+#include <reflow-controller/digio.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>
+
+bool global_error_state;
+
+static void setup_nvic_priorities(void)
 {
 	/* No sub priorities */
 	NVIC_SetPriorityGrouping(2);
 
 	/* Setup Priorities */
-	NVIC_SetPriority(ADC_IRQn, 1);
-	NVIC_SetPriority(DMA2_Stream0_IRQn, 2);
+	NVIC_SetPriority(ADC_IRQn, 2);
+	NVIC_SetPriority(DMA2_Stream0_IRQn, 1);
+	NVIC_SetPriority(DMA2_Stream7_IRQn, 3);
 }
 
-static float pt1000_value;
-static volatile int pt1000_value_status;
+FATFS fs;
+FATFS * const fs_ptr = &fs;
 
-int main() {
-	RCC->AHB1ENR |= RCC_AHB1ENR_GPIOBEN;
-	__DSB();
-	GPIOB->MODER = OUTPUT(2) | OUTPUT(3);
-	GPIOB->ODR |= (1<<2);
+static inline void uart_gpio_config(void)
+{
+	/*
+	 * In case the application is build in debug mode, use the TX/RX Pins on the debug header
+	 * else the Pins on the DIGIO header are configured in the digio module
+	 */
 
+#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();
 
-	//setup_dma(&adc_results, 3);
 	adc_pt1000_setup_meas();
+	oven_driver_init();
+	digio_setup_default_all();
+	led_setup();
+	loudspeaker_setup();
+	reflow_menu_init();
+	safety_adc_init();
 
-	while(1) {
-		pt1000_value_status = adc_pt1000_get_current_resistance(&pt1000_value);
-	}
+	uart_gpio_config();
+	setup_shell_uart(&shell_uart);
 
+	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.gdb

@@ -0,0 +1,8 @@
+target extended-remote :2331
+monitor speed 4000
+monitor reset
+load
+monitor reset
+kill
+quit
+

stm-firmware/program-device.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+if [[ -z $1 ]]; then
+	echo "Usage: $0 <ELF-file>"
+	exit -1
+fi
+
+JLinkGDBServer -if SWD -device STM32F407VE &
+sleep 2
+
+# Check if GDB server is still running
+gdbpid=`pidof JLinkGDBServer`
+
+if [[ $gdbpid == "" ]]; then
+	echo ""
+	echo "GDB Server not running! Check target connection."
+	exit
+fi
+
+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

@@ -0,0 +1,90 @@
+/* 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/rotary-encoder.h>
+#include <stm-periph/clock-enable-manager.h>
+#include <stm-periph/stm32-gpio-macros.h>
+#include <helper-macros/helper-macros.h>
+
+static inline void rotary_encoder_setup_pins(void)
+{
+	rcc_manager_enable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(ROTARY_ENCODER_RCC_MASK));
+	ROTARY_ENCODER_PORT->MODER &= MODER_DELETE(ROTARY_ENCODER_PIN1) & MODER_DELETE(ROTARY_ENCODER_PIN2);
+	ROTARY_ENCODER_PORT->MODER |= ALTFUNC(ROTARY_ENCODER_PIN1) | ALTFUNC(ROTARY_ENCODER_PIN2);
+	SETAF(ROTARY_ENCODER_PORT, ROTARY_ENCODER_PIN1, ROTARY_ENCODER_PORT_ALTFUNC);
+	SETAF(ROTARY_ENCODER_PORT, ROTARY_ENCODER_PIN2, ROTARY_ENCODER_PORT_ALTFUNC);
+}
+
+void rotary_encoder_setup(void)
+{
+	rcc_manager_enable_clock(&RCC->APB1ENR, BITMASK_TO_BITNO(ROTARY_ENCODER_TIMER_RCC_MASK));
+	rotary_encoder_setup_pins();
+
+	ROTARY_ENCODER_TIMER->ARR = 0xFFFF;
+	ROTARY_ENCODER_TIMER->CNT = 0;
+	ROTARY_ENCODER_TIMER->CR2 = 0;
+	ROTARY_ENCODER_TIMER->SMCR = TIM_SMCR_SMS_0 | TIM_SMCR_SMS_1;
+	ROTARY_ENCODER_TIMER->CCMR1 = TIM_CCMR1_CC1S_0 | TIM_CCMR1_CC2S_0;
+	ROTARY_ENCODER_TIMER->CCER = TIM_CCER_CC1P | TIM_CCER_CC2P;
+	ROTARY_ENCODER_TIMER->PSC = 0;
+	ROTARY_ENCODER_TIMER->CR1 = TIM_CR1_CEN;
+}
+
+uint32_t rotary_encoder_get_abs_val(void)
+{
+	return (uint32_t)ROTARY_ENCODER_TIMER->CNT;
+}
+
+int32_t rotary_encoder_get_change_val(void)
+{
+	static uint32_t last_val = 0;
+	uint32_t val;
+	int32_t diff;
+
+	val = rotary_encoder_get_abs_val();
+
+	diff = val - last_val;
+
+	if (val > last_val) {
+		if (diff > (0xFFFF/2))
+			diff = -(last_val + 0x10000-val);
+	} else {
+		if (ABS(diff) > (0xFFFF/2))
+			diff = 0x10000 - last_val + val;
+	}
+
+	last_val = val;
+
+	return diff;
+}
+
+void rotary_encoder_stop(void)
+{
+	ROTARY_ENCODER_TIMER->CR1 = 0;
+	ROTARY_ENCODER_TIMER->CR2 = 0;
+	ROTARY_ENCODER_TIMER->ARR = 0;
+	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/setup/system_stm32f4xx.c

@@ -114,7 +114,7 @@
   * @{
   */
 
-#include "stm32f4xx.h"
+#include <stm32/stm32f4xx.h>
 
 /**
   * @}
@@ -399,7 +399,7 @@ static void SetSysClock(void)
     RCC->CFGR |= RCC_CFGR_SW_PLL;
 
     /* Wait till the main PLL is used as system clock source */
-    while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_PLL);
+    while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_PLL)
     {
     }
   }

stm-firmware/shell.c

@@ -0,0 +1,551 @@
+/* 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 <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[600];
+
+static shellmatta_retCode_t shell_cmd_ver(const shellmatta_handle_t   handle,
+					  const char                  *arguments,
+					  uint32_t                    length)
+{
+	(void)arguments;
+	(void)length;
+	uint32_t low_id;
+	uint32_t mid_id;
+	uint32_t high_id;
+
+	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"
+					"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,
+						uint32_t                    length)
+{
+	(void)arguments;
+	(void)length;
+
+	shellmatta_printf(handle,
+			  "DIGIO0 DIGIO1 DIGIO2 DIGIO3 LED0 LED1 LS\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());
+
+	return SHELLMATTA_OK;
+}
+
+static shellmatta_retCode_t shell_cmd_digio_set(const shellmatta_handle_t   handle,
+						const char                  *arguments,
+						uint32_t                    length)
+{
+	(void)length;
+	(void)handle;
+	int num = 100;
+	int state;
+	char buff[64];
+	char *curr_token;
+
+	strncpy(buff, arguments, sizeof(buff)-1);
+	buff[63] = '\0';
+
+	curr_token = strtok(buff, " ");
+	curr_token = strtok(NULL, " ");
+	if (!curr_token)
+		return SHELLMATTA_ERROR;
+
+	num = atoi(curr_token);
+
+	if (!curr_token)
+		return SHELLMATTA_ERROR;
+
+	curr_token = strtok(NULL, " ");
+	state = atoi(curr_token);
+
+	if (num < 4 && num >= 0)
+		digio_set(num, state);
+	else if (num >= 4 && num <= 5)
+		led_set(num - 4, state);
+	else if (num == 6)
+		loudspeaker_set(state);
+	else
+		return SHELLMATTA_ERROR;
+
+	return SHELLMATTA_OK;
+}
+
+static shellmatta_retCode_t shell_cmd_pt1000_res(const shellmatta_handle_t   handle,
+						 const char                  *arguments,
+						 uint32_t length)
+{
+	(void)arguments;
+	(void)length;
+	float resistance;
+	int pt1000_status;
+	enum adc_pt1000_error pt1000_flags;
+	char display_status[100];
+	float temp;
+	int temp_conv_status;
+	const char *temp_prefix;
+
+	display_status[0] = 0;
+
+	pt1000_status = adc_pt1000_get_current_resistance(&resistance);
+
+	if (pt1000_status == 2) {
+		strcat(display_status, " UNSTABLE ");
+	} else if (pt1000_status) {
+		pt1000_flags = adc_pt1000_check_error();
+		if (pt1000_flags & ADC_PT1000_INACTIVE)
+			strcat(display_status, " DEACTIVATED ");
+		else if (pt1000_flags & ADC_PT1000_WATCHDOG_ERROR)
+			strcat(display_status, " WATCHDOG ");
+		else if (pt1000_flags & ADC_PT1000_OVERFLOW)
+			strcat(display_status, " OVERFLOW ");
+	} else {
+		strcpy(display_status, "VALID");
+	}
+
+	temp_conv_status = temp_converter_convert_resistance_to_temp(resistance, &temp);
+	switch (temp_conv_status) {
+	case 1:
+		temp_prefix = ">";
+		break;
+	case -1:
+		temp_prefix = "<";
+		break;
+	case 0:
+		/* FALLTHRU */
+	default:
+		temp_prefix = "";
+		break;
+	}
+
+	shellmatta_printf(handle, "PT1000 resistance: %.2f Ohm (%s%.1f °C) [%s]\r\n", resistance, temp_prefix,temp, display_status);
+
+	return SHELLMATTA_OK;
+}
+static shellmatta_retCode_t shell_cmd_clear_error_status(const shellmatta_handle_t handle, const char *arguments,
+							 uint32_t length)
+{
+	(void)arguments;
+	(void)length;
+	(void)handle;
+
+	adc_pt1000_clear_error();
+
+	return SHELLMATTA_OK;
+}
+
+static shellmatta_retCode_t shell_cmd_uptime(const shellmatta_handle_t   handle,
+					     const char                  *arguments,
+					     uint32_t length)
+{
+	(void)arguments;
+	(void)length;
+	uint32_t days;
+	uint32_t hours;
+	uint32_t mins;
+	uint32_t secs;
+
+	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,
+					  uint32_t length)
+{
+	(void)arguments;
+	(void)length;
+
+	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,
+					  uint32_t length)
+{
+	(void)arguments;
+	(void)length;
+
+	uint32_t rot_val;
+
+	rot_val = rotary_encoder_get_abs_val();
+	//delta = rotary_encoder_get_change_val();
+	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                           */
+//    char                    *cmdAlias;  /**< command alias                          */
+//    char                    *helpText;  /**< help text to print in "help" command   */
+//    char                    *usageText; /**< usage text to print on parameter error */
+//    shellmatta_cmdFct_t     cmdFct;     /**< pointer to the cmd callack function    */
+//    struct shellmatta_cmd   *next;      /**< pointer to next command or NULL        */
+//} shellmatta_cmd_t;
+
+static shellmatta_cmd_t cmd[15] = {
+	{
+		.cmd = "version",
+		.cmdAlias = "ver",
+		.helpText = "Print firmware version",
+		.usageText = NULL,
+		.cmdFct = shell_cmd_ver,
+		.next = &cmd[1],
+	},
+	{
+		.cmd = "pt1000",
+		.cmdAlias = "pt",
+		.helpText = "Get current filtered and calibrated PT1000 resistance",
+		.usageText = NULL,
+		.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[4],
+	},
+	{
+		.cmd = "digio-get",
+		.cmdAlias = "dg",
+		.helpText = "Read all digital input/output ports",
+		.usageText = NULL,
+		.cmdFct = shell_cmd_digio_get,
+		.next = &cmd[5],
+	},
+	{
+		.cmd = "digio-set",
+		.cmdAlias = "ds",
+		.helpText = "Set DIGIO Port",
+		.usageText = "digio-set <num> <state>",
+		.cmdFct = shell_cmd_digio_set,
+		.next = &cmd[6],
+	},
+	{
+		.cmd = "uptime",
+		.cmdAlias = "upt",
+		.helpText = "Get uptime in seconds",
+		.usageText = "",
+		.cmdFct = shell_cmd_uptime,
+		.next = &cmd[7],
+	},
+	{
+		.cmd = "calibrate",
+		.cmdAlias = "cal",
+		.helpText = "Calibrate resistance measurement",
+		.usageText = "",
+		.cmdFct = shell_cmd_cal,
+		.next = &cmd[8],
+	},
+	{
+		.cmd = "meminfo",
+		.cmdAlias = NULL,
+		.helpText = "Get information about memory usage",
+		.usageText = "",
+		.cmdFct = shell_meminfo,
+		.next = &cmd[9],
+	},
+	{
+		.cmd = "rotary-encoder",
+		.cmdAlias = "rot",
+		.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(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;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)
+		return;
+
+	shellmatta_processData(shell, (char *)data, (uint32_t)len);
+}
+
+void shell_print_string(shellmatta_handle_t shell, const char *string)
+{
+	if (!shell)
+		return;
+
+	shellmatta_write(shell, (char *)string, strlen(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

@@ -0,0 +1,155 @@
+/* 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 <stm-periph/clock-enable-manager.h>
+#include <helper-macros/helper-macros.h>
+#include <stdlib.h>
+
+struct rcc_enable_count {
+	volatile uint32_t *rcc_reg_addr;
+	uint32_t enable_bit_cnt;
+	uint8_t rcc_enable_bit_pos;
+};
+
+#if RCC_ENABLE_MANAGER_STATIC
+
+static struct rcc_enable_count enable_count_list[RCC_ENABLE_MANAGER_COUNT] = {0};
+
+#else
+#error "RCC manager with dynamic memory not implemented!"
+#endif
+
+#if RCC_ENABLE_MANAGER_STATIC
+static struct rcc_enable_count *search_enable_entry_in_list(volatile uint32_t *reg_addr, uint8_t bit_pos)
+{
+	unsigned int i;
+	struct rcc_enable_count *ret_element = NULL;
+	struct rcc_enable_count *current_element;
+
+	for (i = 0; i < COUNT_OF(enable_count_list); i++) {
+		current_element = &enable_count_list[i];
+
+		/* Check if register address and bit position match */
+		if (reg_addr != current_element->rcc_reg_addr)
+			continue;
+		if (bit_pos != current_element->rcc_enable_bit_pos)
+			continue;
+
+		/* Found entry. Wohoo! */
+		ret_element = current_element;
+	}
+
+	return ret_element;
+}
+
+static struct rcc_enable_count *enable_entry_list_get_free_entry()
+{
+	struct rcc_enable_count *ret_ptr = NULL;
+	const int list_len = COUNT_OF(enable_count_list);
+	int i;
+
+	for (i = 0; i < list_len; i++) {
+		if (enable_count_list[i].rcc_reg_addr == NULL) {
+			ret_ptr = &enable_count_list[i];
+
+			/* Clear the count value to be safe */
+			ret_ptr->enable_bit_cnt = 0;
+			break;
+		}
+	}
+
+	return ret_ptr;
+}
+
+static void enable_entry_list_remove_entry(struct rcc_enable_count *entry)
+{
+	if (!entry)
+		return;
+
+	entry->rcc_reg_addr = NULL;
+	entry->enable_bit_cnt = 0;
+	entry->rcc_enable_bit_pos = 0;
+}
+#endif
+
+int rcc_manager_enable_clock(volatile uint32_t *rcc_enable_register, uint8_t bit_no)
+{
+	int ret_val = 0;
+	struct rcc_enable_count *entry;
+
+	if (!rcc_enable_register || bit_no > 31) {
+		return -1000;
+	}
+
+	/* Enable the clock in any case, no matter what follows */
+	*rcc_enable_register |= (1U<<bit_no);
+
+	/* Check if bit is already in list */
+	entry = search_enable_entry_in_list(rcc_enable_register, bit_no);
+
+	if (!entry) {
+		/* Create ne entry at first free place in list */
+		entry = enable_entry_list_get_free_entry();
+
+		/* Check if entry is valid. If not return */
+		if (!entry) {
+			ret_val = -1;
+			goto ret_error_code;
+		}
+
+		/* Set entry */
+		entry->rcc_reg_addr = rcc_enable_register;
+		entry->rcc_enable_bit_pos = bit_no;
+	}
+
+	/* Increment enable counter */
+	entry->enable_bit_cnt++;
+
+ret_error_code:
+	return ret_val;
+}
+
+int rcc_manager_disable_clock(volatile uint32_t *rcc_enable_register, uint8_t bit_no)
+{
+	int ret_val = -1;
+	struct rcc_enable_count *entry;
+
+	if (!rcc_enable_register || bit_no > 31) {
+		return -1000;
+	}
+
+	entry = search_enable_entry_in_list(rcc_enable_register, bit_no);
+
+	/* If entry is found and has a count of zero, disable clock */
+	if (entry) {
+		/* Found entry => Decrement count and delete if zero */
+		entry->enable_bit_cnt--;
+		if (entry->enable_bit_cnt <= 0) {
+			enable_entry_list_remove_entry(entry);
+
+			/* Disable clock */
+			*rcc_enable_register &= ~(1U<<bit_no);
+		}
+
+		ret_val = 0;
+	}
+
+	return ret_val;
+}

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

@@ -0,0 +1,315 @@
+/* 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/>.
+ */
+
+/**
+ * @file dma-ring-buffer.c
+ * @brief DMA Ring buffer implemenation
+ */
+
+/**
+ * @addtogroup dma-ring-buffer
+ * @{
+ */
+
+#include <stm-periph/dma-ring-buffer.h>
+#include <stm-periph/clock-enable-manager.h>
+#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;
+	int (*clk_func)(volatile uint32_t *, uint8_t);
+
+	if (clk_en)
+		clk_func = rcc_manager_enable_clock;
+	else
+		clk_func = rcc_manager_disable_clock;
+
+	switch (base_dma) {
+	case 1:
+		ret_val = clk_func(&RCC->AHB1ENR, BITMASK_TO_BITNO(RCC_AHB1ENR_DMA1EN));
+		break;
+	case 2:
+		ret_val = clk_func(&RCC->AHB1ENR, BITMASK_TO_BITNO(RCC_AHB1ENR_DMA2EN));
+		break;
+	default:
+		ret_val = -1000;
+		break;
+	}
+
+	return ret_val;
+}
+
+int dma_ring_buffer_periph_to_mem_initialize(struct dma_ring_buffer_to_mem *dma_buffer, uint8_t base_dma_id,
+					     DMA_Stream_TypeDef *dma_stream, size_t buffer_element_count, size_t element_size,
+					     volatile void *data_buffer, void* src_reg, uint8_t dma_trigger_channel)
+{
+	int ret_val = 0;
+
+	if (!dma_buffer || !dma_stream || !data_buffer || !src_reg)
+		return -1000;
+
+	if (dma_trigger_channel > 7)
+		return -1007;
+
+	dma_buffer->base_dma_id = base_dma_id;
+
+	ret_val = dma_ring_buffer_switch_clock_enable(base_dma_id, true);
+	if (ret_val)
+		return ret_val;
+
+	dma_buffer->dma = dma_stream;
+	dma_buffer->get_idx = 0;
+	dma_buffer->buffer_count = buffer_element_count;
+
+	dma_buffer->data_ptr = data_buffer;
+	dma_buffer->element_size = element_size;
+
+	dma_stream->PAR = (uint32_t)src_reg;
+	dma_stream->M0AR = (uint32_t)data_buffer;
+	dma_stream->NDTR = buffer_element_count;
+	dma_stream->NDTR = buffer_element_count;
+
+	dma_stream->CR |= (dma_trigger_channel<<25) | DMA_SxCR_MINC | DMA_SxCR_CIRC | DMA_SxCR_EN;
+
+	return 0;
+}
+
+int dma_ring_buffer_periph_to_mem_get_data(struct dma_ring_buffer_to_mem *buff, const volatile void **data_buff, size_t *len)
+{
+	int ret_code = 0;
+	uint32_t ndtr;
+	size_t put_idx;
+
+	if (!buff || !data_buff || !len)
+		return -1;
+
+	ndtr = buff->dma->NDTR;
+	put_idx = buff->buffer_count - ndtr;
+
+	/* Check if wrap around */
+	if (put_idx < buff->get_idx) {
+		/* Available data wraps around end of buffer: Return first part upt to the end of the ring buffer */
+		*data_buff = &(((char *)buff->data_ptr)[buff->get_idx * buff->element_size]);
+		*len = buff->buffer_count - buff->get_idx;
+		buff->get_idx = 0;
+		ret_code = 2;
+	} else if (put_idx > buff->get_idx) {
+		/* Data does not wrap around ring buffer. Return full data */
+		*data_buff = &(((char *)buff->data_ptr)[buff->get_idx * buff->element_size]);
+		*len = put_idx - buff->get_idx;
+		buff->get_idx += *len;
+		ret_code = 1;
+	} else {
+		/* No new data */
+		*len = 0;
+	}
+
+	return ret_code;
+}
+
+void dma_ring_buffer_periph_to_mem_stop(struct dma_ring_buffer_to_mem *buff)
+{
+	if (!buff || !buff->dma)
+		return;
+
+	buff->dma->CR = 0;
+	buff->dma->NDTR = 0;
+	buff->dma->M1AR = 0;
+	buff->dma->FCR = 0;
+
+	dma_ring_buffer_switch_clock_enable(buff->base_dma_id, false);
+
+	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)
+		return -1000;
+
+	dma_buffer->dma = dma_stream;
+	dma_buffer->dma_base_id = base_dma_id;
+	dma_buffer->src_buffer = data_buffer;
+	dma_buffer->buffer_count = buffer_element_count;
+	dma_buffer->element_size = element_size;
+	dma_buffer->sw_put_idx = 0U;
+	dma_buffer->dma_get_idx_current = 0U;
+	dma_buffer->dma_get_idx_future = 0U;
+
+	dma_ring_buffer_switch_clock_enable(base_dma_id, true);
+
+	dma_stream->PAR = (uint32_t)dest_reg;
+	dma_stream->CR = DMA_SxCR_MINC | DMA_SxCR_TCIE | (dma_trigger_channel<<25) | DMA_SxCR_DIR_0;
+
+	return 0;
+}
+
+static void queue_or_start_dma_transfer(struct dma_ring_buffer_to_periph *buff)
+{
+	uint32_t dma_transfer_cnt;
+
+	if (!buff)
+		return;
+
+	/* Check if DMA is running. Do nothing in this case. Will be stated from interrupt */
+	if (buff->dma_get_idx_current != buff->dma_get_idx_future)
+		return;
+
+	/* No new data to transfer */
+	if (buff->sw_put_idx == buff->dma_get_idx_current)
+		return;
+
+	/* Calculate future get idx. Stop at end of buffer to prevent impossible wrap around */
+	if (buff->sw_put_idx < buff->dma_get_idx_current && buff->sw_put_idx != 0) {
+		buff->dma_get_idx_future = 0U;
+		dma_transfer_cnt = buff->buffer_count - buff->dma_get_idx_current;
+	} else {
+		buff->dma_get_idx_future = buff->sw_put_idx;
+		if (buff->sw_put_idx == 0)
+			dma_transfer_cnt = buff->buffer_count - buff->dma_get_idx_current;
+		else
+			dma_transfer_cnt = buff->sw_put_idx - buff->dma_get_idx_current;
+	}
+
+	buff->dma->NDTR = dma_transfer_cnt;
+	buff->dma->M0AR = (uint32_t)&((char *)buff->src_buffer)[buff->dma_get_idx_current * buff->element_size];
+	buff->dma->CR |= DMA_SxCR_EN;
+}
+
+int dma_ring_buffer_mem_to_periph_insert_data(struct dma_ring_buffer_to_periph *buff, const void *data_to_insert, size_t count)
+{
+	int ret = 0;
+	size_t free_item_count;
+	char *insert_ptr;
+	char *dest_ptr;
+	void *ptr;
+	size_t first_round_count;
+
+	if (!buff || !data_to_insert || !count)
+		return -1000;
+
+	/* Check if data fits into buffer minus one element. If not: try full-1 buffer and rest
+	 * Buffer is not allowed to be completely full, because I cannot ddifferentiate a full buffer from a completely empty one
+	 */
+	if (count >= buff->buffer_count) {
+		ret = dma_ring_buffer_mem_to_periph_insert_data(buff, data_to_insert, buff->buffer_count - 1);
+		if (ret)
+			goto return_retval;
+		ptr = (void *)(((char *)data_to_insert) + ((buff->buffer_count-1) * buff->element_size));
+		ret = dma_ring_buffer_mem_to_periph_insert_data(buff, ptr, count - buff->buffer_count + 1);
+		goto return_retval;
+	}
+
+	/* Wait for buffer to be able to handle input */
+	do {
+		free_item_count = buff->buffer_count - calculate_ring_buffer_fill_level(buff->buffer_count, buff->dma_get_idx_current, buff->sw_put_idx);
+	} while (free_item_count < count+1);
+
+	/* Fillup buffer (max is buffer end, wrap around afterwards) */
+	insert_ptr = (char *)data_to_insert;
+	dest_ptr = &((char *)buff->src_buffer)[buff->sw_put_idx * buff->element_size];
+
+	/* Check if data completely fits into memory starting from put index */
+	if (buff->buffer_count - buff->sw_put_idx >= count) {
+		/* Copy data and move put index */
+		memcpy(dest_ptr, insert_ptr, buff->element_size * count);
+		buff->sw_put_idx += count;
+
+		/* If buffer is used up to last element, set put index to beginning */
+		if(buff->sw_put_idx >= buff->buffer_count)
+			buff->sw_put_idx = 0;
+	} else {
+		/* Fill up to end of buffer and fill rest after wrap around */
+		first_round_count = buff->element_size * (buff->buffer_count - buff->sw_put_idx);
+		memcpy(dest_ptr, insert_ptr, first_round_count);
+		insert_ptr += first_round_count;
+		memcpy((void *)buff->src_buffer, insert_ptr, count - first_round_count);
+
+		/* Move put index */
+		buff->sw_put_idx = count - first_round_count;
+	}
+
+	/* Queue the DMA transfer. If DMA is already enabled, this has no effect
+	 * DMA is triggerd from interrupt in this case
+	 */
+	queue_or_start_dma_transfer(buff);
+
+return_retval:
+	return ret;
+}
+
+void dma_ring_buffer_mem_to_periph_int_callback(struct dma_ring_buffer_to_periph *buff)
+{
+	/* update current get index because DMA is finished */
+	buff->dma_get_idx_current = buff->dma_get_idx_future;
+
+	/* Start new DMA transfer if not all data is trasnferred yet */
+	queue_or_start_dma_transfer(buff);
+}
+
+void dma_ring_buffer_mem_to_periph_stop(struct dma_ring_buffer_to_periph *buff)
+{
+	/* Stop DMA and clock */
+	buff->dma->CR = 0;
+	dma_ring_buffer_switch_clock_enable(buff->dma_base_id, false);
+
+	/* Reset the structure */
+	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

@@ -0,0 +1,216 @@
+/* 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 <stm-periph/uart.h>
+#include <stm32/stm32f4xx.h>
+#include <stm-periph/clock-enable-manager.h>
+#include <stm-periph/stm32-gpio-macros.h>
+#include <stm-periph/dma-ring-buffer.h>
+#include <string.h>
+
+int uart_init(struct stm_uart *uart)
+{
+	int ret_val = 0;
+	uint32_t cr3 = 0;
+	uint32_t cr1 = 0;
+
+	if (!uart)
+		return -1000;
+
+	rcc_manager_enable_clock(uart->rcc_reg, uart->rcc_bit_no);
+
+	/* 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_change_brr(struct stm_uart *uart, uint32_t brr)
+{
+	if (!uart || !uart->uart_dev)
+		return;
+
+	uart->brr_val = brr;
+	uart->uart_dev->BRR = brr;
+}
+
+void uart_disable(struct stm_uart *uart)
+{
+	if (!uart)
+		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_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(uart, data[i]);
+}
+
+void uart_send_string(struct stm_uart *uart, const char *string)
+{
+	int i;
+
+	for (i = 0; string[i] != '\0'; i++)
+		uart_send_char(uart, string[i]);
+}
+
+void uart_send_array_with_dma(struct stm_uart *uart, const char *data, uint32_t 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(struct stm_uart *uart, const char *string)
+{
+	size_t len;
+
+	len = strlen(string);
+	uart_send_array_with_dma(uart, string, (uint32_t)len);
+}
+
+int uart_receive_data_with_dma(struct stm_uart *uart, const char **data, size_t *len)
+{
+	if (!uart)
+		return -1000;
+
+	return dma_ring_buffer_periph_to_mem_get_data(&uart->rx_ring_buff, (const volatile void **)data, len);
+}
+
+char uart_get_char(struct stm_uart *uart)
+{
+	if (!uart)
+		return 0;
+	/* Wait for data to be available */
+	while (!(uart->uart_dev->SR & USART_SR_RXNE));
+
+	return (char)uart->uart_dev->DR;
+}
+
+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

@@ -0,0 +1,35 @@
+/* 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 <stm-periph/unique-id.h>
+
+#define LOW_WORD_ADDR (0x1FFF7A10UL)
+#define MID_WORD_ADDR (LOW_WORD_ADDR+4U)
+#define HIGH_WORD_ADDR (LOW_WORD_ADDR+8U)
+
+void unique_id_get(uint32_t *high, uint32_t *mid, uint32_t *low)
+{
+	if (!high || !mid || !low)
+		return;
+
+	*low = *((uint32_t *)LOW_WORD_ADDR);
+	*mid = *((uint32_t *)MID_WORD_ADDR);
+	*high = *((uint32_t *)HIGH_WORD_ADDR);
+}

stm-firmware/stm32f407vet6_flash.ld

@@ -36,8 +36,8 @@ ENTRY(Reset_Handler)
 _estack = 0x20020000;    /* end of 128K RAM on AHB bus*/
 
 /* Generate a link error if heap and stack don't fit into RAM */
-_Min_Heap_Size = 0X0000;      /* required amount of heap (DEFAULT 0) */
-_Min_Stack_Size = 0x400 ; /* required amount of stack */
+_Min_Heap_Size = 0x2100;      /* required amount of heap (DEFAULT 0) */
+_Min_Stack_Size = 0x3000 ; /* required amount of stack */
 /* recommended min stack size for printf=0x2000, orig = 0x400 */
 
 /* Specify the memory areas */
@@ -112,38 +112,26 @@ SECTIONS
 
   _siccmram = LOADADDR(.ccmram);
 
-  /* CCM-RAM section 
-  * 
-  * IMPORTANT NOTE! 
-  * If initialized variables will be placed in this section, 
-  * the startup code needs to be modified to copy the init-values.  
-  */
-  .ccmram :
+  /* CCM-RAM section  */
+  .ccmram (NOLOAD):
   {
     . = ALIGN(4);
     _sccmram = .;       /* create a global symbol at ccmram start */
     *(.ccmram)
     *(.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 */
     *(.data)           /* .data sections */
     *(.data*)          /* .data* sections */
-
     . = ALIGN(4);
     _edata = .;        /* define a global symbol at data end */
   } >RAM AT> FLASH
@@ -152,7 +140,7 @@ SECTIONS
 
   /* Uninitialized data section */
   . = ALIGN(4);
-  .bss :
+  .bss (NOLOAD):
   {
     /* This is used by the startup in order to initialize the .bss secion */
     _sbss = .;         /* define a global symbol at bss start */
@@ -167,16 +155,16 @@ SECTIONS
   } >RAM
 
   /* User_heap_stack section, used to check that there is enough RAM left */
-  ._user_heap_stack :
+  ._user_heap_stack (NOLOAD):
   {
-    . = ALIGN(4);
+    . = ALIGN(8);
     PROVIDE (heap_low = .); /* for _sbrk */
     PROVIDE ( end = . );
     PROVIDE ( _end = . );
     . = . + _Min_Heap_Size;
     PROVIDE (heap_top = .); /* for _sbrk */
     . = . + _Min_Stack_Size;
-    . = ALIGN(4);
+    . = ALIGN(8);
   } >RAM
 
   /* MEMORY_bank1 section, code must be located here explicitly            */

stm-firmware/syscalls.c

@@ -1,41 +1,112 @@
-#include <uart/uart.h>
+/* 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/>.
+ */
 
-char* _sbrk(int incr) {
-            extern char heap_low;    // Defined by the linker
-            extern char heap_top;
-            static char *heap_end;
-            char *prev_heap_end;
+#include <stm-periph/uart.h>
+#include <sys/types.h>
+#include <errno.h>
+#include <stddef.h>
 
-            if (heap_end == 0) {
-              heap_end = &heap_low;
-            }
-            prev_heap_end = heap_end;
-            if (heap_end + incr > &heap_top) {
-              return 0;
-            }
+extern struct stm_uart shell_uart;
+
+char* _sbrk(int incr)
+{
+	extern char heap_low;    // Defined by the linker
+	extern char heap_top;
+	static char *heap_end;
+	char *prev_heap_end;
+
+	if (heap_end == 0) {
+		heap_end = &heap_low;
+	}
+
+	prev_heap_end = heap_end;
+
+
+	if (heap_end + incr > &heap_top) {
+		errno = ENOMEM;
+		return (char *)-1;
+	}
+
+	heap_end += incr;
+
+	return (char *) prev_heap_end;
+}
+
+int _isatty(int fd)
+{
+	(void)fd;
 
-            heap_end += incr;
-            return (char*) prev_heap_end;
-          }
-int _isatty(int fd) {
 	return 1;
 }
-int _close(int fd) {
+
+int _close(int fd)
+{
+	(void)fd;
+
 	return 0;
 }
-int _open(int fd) {
+
+int _open(int fd)
+{
+	(void)fd;
+
 	return 0;
 }
-int _fstat(void) {
+
+int _fstat(void)
+{
 	return 0;
 }
-int _lseek(void) {
+
+int _lseek(void)
+{
 	return 0;
 }
-int _read(void) {
+
+int _read(void)
+{
 	return 0;
 }
-int _write(int fd, const void *buf, int count) {
-	sendString((char*)buf, count);
+
+int _write(int fd, const void *buf, int count)
+{
+	if (fd == 1)
+		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

@@ -1,30 +1,107 @@
-#include <systick.h>
-#include <stm32f4xx.h>
-#include <core_cm4.h>
+/* 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/>.
+ */
 
-volatile uint32_t wait_tick_ms;
-volatile uint64_t global_tick_ms;
+/**
+ * @file systick.c
+ */
+
+#include <reflow-controller/systick.h>
+#include <stm32/stm32f4xx.h>
+#include <cmsis/core_cm4.h>
+
+volatile uint32_t wait_tick_ms = 0UL;
+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);
 }
 
-/**
- * @brief Wait for x milliseconds
- *
- * This function is not reentrant and must not be called from an interrupt
- *
- * @warning Do not use in interrupt context
- * @param ms wait time in ms
- */
 void systick_wait_ms(uint32_t ms)
 {
 	wait_tick_ms = 0UL;
 	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
  *
@@ -32,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 */
-	wait_tick_ms++;
-	global_tick_ms++;
+	static uint32_t pre_tick = 0UL;
+
+	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

@@ -0,0 +1,75 @@
+/* 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/temp-converter.h>
+#include <reflow-controller/temp-converter-data.h>
+#include <helper-macros/helper-macros.h>
+
+static const float temp_lookup[(TEMP_CONVERSION_MAX_RES-TEMP_CONVERSION_MIN_RES) / TEMP_CONVERSION_RES_STEP+1] = {TEMP_CONVERSION_ARRAY_DATA};
+
+int temp_converter_convert_resistance_to_temp(float resistance, float *temp_out)
+{
+	int ret_val;
+	unsigned int i;
+	unsigned int lower_idx = COUNT_OF(temp_lookup) - 1;
+	float diff_to_low_resistance;
+	float diff_high_low;
+	float low;
+
+	/* Check pointer */
+	if (!temp_out)
+		return -1000;
+
+	if (resistance < TEMP_CONVERSION_MIN_RES) {
+		*temp_out = temp_lookup[0];
+		ret_val = -1;
+		goto return_ret_val;
+	} else if (resistance > TEMP_CONVERSION_MAX_RES) {
+		*temp_out = temp_lookup[COUNT_OF(temp_lookup)-1];
+		ret_val = 1;
+		goto return_ret_val;
+	}
+
+	/* Resistance is in range */
+	ret_val = 0;
+
+	/* Calculate lower index for given reistance */
+	for (i = 1; i < COUNT_OF(temp_lookup); i++) {
+		if (resistance <= TEMP_CONVERSION_MIN_RES + TEMP_CONVERSION_RES_STEP * i) {
+			lower_idx = i - 1;
+			break;
+		}
+	}
+
+	/* Get the lower temperature limit of the current range */
+	low = temp_lookup[lower_idx];
+
+	/* Difference to higher limit */
+	diff_high_low = temp_lookup[lower_idx+1] - low;
+
+	/* Resistance difference to lower limit's resistance value */
+	diff_to_low_resistance = resistance - (float)(TEMP_CONVERSION_MIN_RES + TEMP_CONVERSION_RES_STEP * lower_idx);
+
+	/* Calculate output temperature */
+	*temp_out = (diff_to_low_resistance / TEMP_CONVERSION_RES_STEP) * diff_high_low + low;
+
+return_ret_val:
+	return ret_val;
+}

stm-firmware/uart/uart.c

@@ -1,44 +0,0 @@
-/*
- * uart.c
- *
- *  Created on: Dec 15, 2014
- *      Author: shino-chan
- */
-//USART2
-//PA2 => TX
-//PA3 => RX
-//Alternate Function 7
-#include <uart/uart.h>
-#include <stm32f4xx.h>
-
-void initUART() {
-	__DSB();
-	RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
-	RCC->APB1ENR |= RCC_APB1ENR_USART2EN;
-	__DSB();
-
-	GPIOA->MODER |= (1<<5);
-	GPIOA->AFR[0] |= (7<<8); //Enable Clock
-	GPIOA->MODER |= (1<<5);
-	GPIOA->AFR[0] |= (7<<8);
-	asm("nop");
-	asm("nop");
-	asm("nop");
-	USART2->BRR = 0x1117; //Baudrate  273.4375=>0x1117 9600baud bei 42MHz Periph
-	USART2->CR1 = USART_CR1_UE | USART_CR1_TE;
-
-}
-void sendChar(char c) {
-	while(!(USART2->SR & USART_SR_TXE));
-	USART2->DR = c;
-
-}
-void sendString(char* s, int count) {
-	int i = 0;
-	for (i = 0; i < count; i++,s++)
-	{
-		if (!(*s))
-			break;
-		sendChar(*s);
-	}
-}

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, "");
+}