Add newest shellmatta and include missing syscalls

measurement-data/Analog_Measurement_Analysis.ipynb

@@ -351,7 +351,8 @@
     "                    (kilo_ohm_sampling1_ht, 'Day 1 Sampling -- Stable circuit -- HT'),\n",
     "                    (kilo_ohm_sampling2, 'Day 2 Sampling -- Stable circuit'),\n",
     "                    (pd.read_csv(r'1000OhmSamplingFixedStableCircuitDay3.csv'), 'Day 3 Sampling -- Stable Circuit (improved)'),\n",
-    "                    (pd.read_csv(r'1000OhmSamplingFixedStableCircuitDay4.csv'), 'Day 4 Sampling -- Stable Circuit (improved)')\n",
+    "                    (pd.read_csv(r'1000OhmSamplingFixedStableCircuitDay4.csv'), 'Day 4 Sampling -- Stable Circuit (improved)'),\n",
+    "                    (pd.read_csv(r'1000OhmSampling-v1.2.csv'), 'Day 1 Sampling v1.2')\n",
     "                   ]\n"
    ]
   },
@@ -410,7 +411,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.1"
+   "version": "3.8.2"
   }
  },
  "nbformat": 4,

stm-firmware/Makefile

@@ -28,7 +28,7 @@ endif
 CFILES += adc-meas.c
 
 # Shellmatta
-CFILES += shellmatta/src/shellmatta.c shellmatta/src/shellmatta_autocomplete.c shellmatta/src/shellmatta_escape.c shellmatta/src/shellmatta_history.c shellmatta/src/shellmatta_utils.c shell.c
+CFILES += shellmatta/src/shellmatta.c shellmatta/src/shellmatta_autocomplete.c shellmatta/src/shellmatta_escape.c shellmatta/src/shellmatta_history.c shellmatta/src/shellmatta_utils.c shellmatta/src/shellmatta_opt.c shell.c
 INCLUDEPATH += -Ishellmatta/api
 # DEFINES += -DSHELLMATTA_STRIP_PRINTF
 
@@ -47,7 +47,14 @@ CFILES += temp-converter.c
 
 CFILES += rotary-encoder.c
 
+CFILES += stack-check.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
+
 DEFINES += -DDEBUGBUILD
+
 ###################################################################################
 CC=arm-none-eabi-gcc
 OBJCOPY=arm-none-eabi-objcopy
@@ -102,10 +109,11 @@ disassemble: $(target).elf
 objcopy: $(target).bin $(target).hex
 
 mrproper: clean
-	rm -f $(target).pro
+	$(QUIET)rm -f $(target).pro
 
 clean:
-	rm -f $(target).elf $(target).bin $(target).hex $(OBJ) $(ASOBJ) $(mapfile).map $(CFILES:%.c=$(OBJDIR)/%.c.d) $(ASFILES:%.S=$(OBJDIR)/%.S.d)
+	@echo "Cleaning up derived files..."
+	$(QUIET)rm -f $(target).elf $(target).bin $(target).hex $(OBJ) $(ASOBJ) $(mapfile).map $(CFILES:%.c=$(OBJDIR)/%.c.d) $(ASFILES:%.S=$(OBJDIR)/%.S.d)
 qtproject:
 	echo -e "TEMPLATE = app\nCONFIG -= console app_bundle qt" > $(target).pro
 	echo -e "SOURCES += $(CFILES) $(ASFILES)" >> $(target).pro

stm-firmware/adc-meas.c

@@ -8,7 +8,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
- * GDSII-Converter is distributed in the hope that it will be useful,
+ * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.

stm-firmware/calibration.c

@@ -8,7 +8,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
- * GDSII-Converter is distributed in the hope that it will be useful,
+ * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
@@ -27,6 +27,8 @@
 #include <stdlib.h>
 #include <float.h>
 
+extern struct stm_uart shell_uart;
+
 void calibration_calculate(float low_measured, float low_setpoint, float high_measured, float high_setpoint,
 			   float *sens_deviation, float *sens_corrected_offset)
 {
@@ -110,7 +112,7 @@ static void wait_for_uart_enter()
 	int uart_recv_status;
 
 	do {
-		uart_recv_status = uart_receive_data_with_dma(&recv_data, &recv_len);
+		uart_recv_status = uart_receive_data_with_dma(&shell_uart, &recv_data, &recv_len);
 		if (uart_recv_status >= 1) {
 			for (iter = 0; iter < recv_len; iter++) {
 				if (recv_data[iter] == '\n' || recv_data[iter] == '\r')

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

@@ -13,7 +13,7 @@ license_header = """/* Reflow Oven Controller
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
-* GDSII-Converter is distributed in the hope that it will be useful,
+* The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

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

@@ -14,7 +14,7 @@ license_header = """/* Reflow Oven Controller
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
-* GDSII-Converter is distributed in the hope that it will be useful,
+* The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

stm-firmware/digio.c

@@ -8,7 +8,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
- * GDSII-Converter is distributed in the hope that it will be useful,
+ * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.

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,733 @@
+#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
+ */
+static int sdio_check_inserted() {
+#if SDIO_ENABLE_INS
+	return ((INS_PORT->IDR & 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 & 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;
+
+	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;
+	if (status.statusstruct.CURRENT_STATE != CURRENT_STATE_TRAN)
+		res = -2;
+	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 {
+			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);
+
+		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,77 @@
+/*
+ * 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();
+
+
+//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)
+
+#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 0
+#define INS_PORT GPIOD // Add this port to port clock mask!
+#define INS_PIN 0
+#define INS_PULLUP 0
+#define INS_ACTIVE_LEVEL 0
+
+
+#endif /* FATFS_SHIMATTA_SDIO_DRIVER_SHIMATTA_SDIO_CONFIG_H_ */

stm-firmware/include/fatfs/diskio.h

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

stm-firmware/include/fatfs/ff.h

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

stm-firmware/include/fatfs/ffconf.h

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

stm-firmware/include/helper-macros/helper-macros.h

@@ -34,4 +34,6 @@
 #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/rotary-encoder.h

@@ -35,7 +35,7 @@ void rotary_encoder_setup(void);
 
 uint32_t rotary_encoder_get_abs_val(void);
 
-int32_t rotary_encoder_get_chage_val(void);
+int32_t rotary_encoder_get_change_val(void);
 
 void rotary_encoder_stop(void);
 

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

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

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

@@ -24,7 +24,7 @@
 #include <stddef.h>
 #include <shellmatta.h>
 
-shellmatta_handle_t shell_init(void);
+shellmatta_handle_t shell_init(shellmatta_write_t write_func);
 
 void shell_handle_input(shellmatta_handle_t shell, const char *data, size_t len);
 

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

@@ -0,0 +1,41 @@
+/* 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 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

@@ -63,5 +63,6 @@ void systick_setup(void);
  */
 void systick_wait_ms(uint32_t ms);
 
+uint64_t systick_get_global_tick();
 
 #endif /* __SYSTICK_H__ */

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

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

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

@@ -28,6 +28,7 @@
 #define PINMASK(pin) ((0x3) << (pin * 2))
 #define SETAF(PORT,PIN,AF)  PORT->AFR[(PIN < 8 ? 0 : 1)] |= AF << ((PIN < 8 ? PIN : (PIN - 8)) * 4)
 #define ANALOG(pin)  (0x03 << (pin * 2))
+#define OTYP_OPENDRAIN(pin) (0x1U << (pin))
 
 #define BITMASK_TO_BITNO(x) (x&0x1?0:x&0x2?1:x&0x4?2:x&0x8?3: \
 		 x&0x10?4:x&0x20?5:x&0x40?6:x&0x80?7: \

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

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

stm-firmware/main.c

@@ -8,7 +8,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
- * GDSII-Converter is distributed in the hope that it will be useful,
+ * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
@@ -37,6 +37,9 @@
 #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 <helper-macros/helper-macros.h>
+#include <fatfs/ff.h>
 
 static void setup_nvic_priorities()
 {
@@ -54,8 +57,57 @@ static volatile int pt1000_value_status;
 static uint32_t rot;
 
 
+
+static inline void uart_gpio_config()
+{
+#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[32];
+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_sell_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);
+}
+
+const char *oven_controller_hello_world = "Hello world :)\n";
+
 int main()
 {
+	FATFS fs;
+	FIL test_file;
 	const char *uart_input;
 	size_t uart_input_len;
 	shellmatta_handle_t shell_handle;
@@ -71,18 +123,39 @@ int main()
 	loudspeaker_setup();
 	rotary_encoder_setup();
 
-	uart_init_with_dma();
+	uart_gpio_config();
+	setup_sell_uart(&shell_uart);
 
-	shell_handle = shell_init();
+	shell_handle = shell_init(write_shell_callback);
 
-	while(1) {
+	if (f_mount(&fs, "0:/", 1) == FR_OK) {
+		f_open(&test_file, "hello-world.txt", FA_OPEN_APPEND | FA_WRITE);
+		f_write(&test_file, oven_controller_hello_world, strlen(oven_controller_hello_world), NULL);
+		f_close(&test_file);
+	}
+
+
+	while (1) {
 		pt1000_value_status = adc_pt1000_get_current_resistance(&pt1000_value);
 		rot = rotary_encoder_get_abs_val();
-		uart_receive_status = uart_receive_data_with_dma(&uart_input, &uart_input_len);
+		uart_receive_status = uart_receive_data_with_dma(&shell_uart, &uart_input, &uart_input_len);
 		if (uart_receive_status >= 1)
 			shell_handle_input(shell_handle, uart_input, uart_input_len);
 	}
 
 }
 
+void sdio_wait_ms(uint32_t ms)
+{
+	systick_wait_ms(ms);
+}
 
+void DMA2_Stream7_IRQHandler()
+{
+	uint32_t hisr = DMA2->HISR;
+	DMA2->HIFCR = hisr;
+
+	if (hisr & DMA_HISR_TCIF7) {
+		uart_tx_dma_complete_int_callback(&shell_uart);
+	}
+}

stm-firmware/rotary-encoder.c

@@ -8,7 +8,7 @@
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
-* GDSII-Converter is distributed in the hope that it will be useful,
+* The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
@@ -21,6 +21,7 @@
 #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)
 {
@@ -51,7 +52,7 @@ uint32_t rotary_encoder_get_abs_val(void)
 	return (uint32_t)ROTARY_ENCODER_TIMER->CNT;
 }
 
-int32_t rotary_encoder_get_chage_val(void)
+int32_t rotary_encoder_get_change_val(void)
 {
 	static uint32_t last_val = 0;
 	uint32_t val;
@@ -61,10 +62,16 @@ int32_t rotary_encoder_get_chage_val(void)
 
 	diff = val - last_val;
 
-	if (diff > 0xEFFF) {
-		diff = 0xFFFF - diff;
+	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;
 }
 

stm-firmware/shell.c

@@ -8,7 +8,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
- * GDSII-Converter is distributed in the hope that it will be useful,
+ * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
@@ -30,6 +30,9 @@
 #include <reflow-controller/calibration.h>
 #include <reflow-controller/temp-converter.h>
 
+#include <reflow-controller/stack-check.h>
+#include <reflow-controller/rotary-encoder.h>
+
 #ifndef GIT_VER
 #define GIT_VER "VERSION NOT SET"
 #endif
@@ -38,15 +41,9 @@ static shellmatta_instance_t shell;
 static char shell_buffer[512];
 static char history_buffer[1024];
 
-static shellmatta_retCode_t write_shell_callback(const char *data, uint32_t len)
-{
-	uart_send_array_with_dma(data, len);
-	return SHELLMATTA_OK;
-}
-
 static shellmatta_retCode_t shell_cmd_ver(const shellmatta_handle_t   handle,
-						    const char                  *arguments,
-						    uint32_t                    length)
+					  const char                  *arguments,
+					  uint32_t                    length)
 {
 	(void)arguments;
 	(void)length;
@@ -57,22 +54,22 @@ static shellmatta_retCode_t shell_cmd_ver(const shellmatta_handle_t   handle,
 	unique_id_get(&high_id, &mid_id, &low_id);
 
 	shellmatta_printf(handle, "Reflow Oven Controller Firmware " xstr(GIT_VER) "\r\n"
-				"Compiled: " __DATE__ " at " __TIME__ "\r\n"
-				"Serial: %08X-%08X-%08X", high_id, mid_id, low_id);
+					"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)
+						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",
+			  "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());
 
@@ -80,8 +77,8 @@ static shellmatta_retCode_t shell_cmd_digio_get(const shellmatta_handle_t   hand
 }
 
 static shellmatta_retCode_t shell_cmd_digio_set(const shellmatta_handle_t   handle,
-						       const char                  *arguments,
-						       uint32_t                    length)
+						const char                  *arguments,
+						uint32_t                    length)
 {
 	(void)length;
 	(void)handle;
@@ -192,8 +189,8 @@ static shellmatta_retCode_t shell_cmd_uptime(const shellmatta_handle_t   handle,
 }
 
 static shellmatta_retCode_t shell_cmd_cal(const shellmatta_handle_t   handle,
-						  const char                  *arguments,
-						  uint32_t length)
+					  const char                  *arguments,
+					  uint32_t length)
 {
 	(void)arguments;
 	(void)length;
@@ -201,6 +198,41 @@ static shellmatta_retCode_t shell_cmd_cal(const shellmatta_handle_t   handle,
 	calibration_sequence_shell_cmd(handle);
 	return SHELLMATTA_OK;
 }
+
+static shellmatta_retCode_t shell_get_sp(const shellmatta_handle_t   handle,
+					 const char                  *arguments,
+					 uint32_t length)
+{
+	(void)arguments;
+	(void)length;
+
+	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());
+	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;
+	int32_t delta;
+
+	rot_val = rotary_encoder_get_abs_val();
+	delta = rotary_encoder_get_change_val();
+	shellmatta_printf(handle, "Rotary encoder value: %u, delta: %d\r\n", rot_val, delta);
+
+	return SHELLMATTA_OK;
+}
+
 //typedef struct shellmatta_cmd
 //{
 //    char                    *cmd;       /**< command name                           */
@@ -211,7 +243,7 @@ static shellmatta_retCode_t shell_cmd_cal(const shellmatta_handle_t   handle,
 //    struct shellmatta_cmd   *next;      /**< pointer to next command or NULL        */
 //} shellmatta_cmd_t;
 
-static shellmatta_cmd_t cmd[7] = {
+static shellmatta_cmd_t cmd[9] = {
 	{
 		.cmd = "version",
 		.cmdAlias = "ver",
@@ -266,17 +298,33 @@ static shellmatta_cmd_t cmd[7] = {
 		.helpText = "Calibrate resistance measurement",
 		.usageText = "",
 		.cmdFct = shell_cmd_cal,
+		.next = &cmd[7],
+	},
+	{
+		.cmd = "get-stack-pointer",
+		.cmdAlias = "sp",
+		.helpText = "Get the stack pointer",
+		.usageText = "",
+		.cmdFct = shell_get_sp,
+		.next = &cmd[8],
+	},
+	{
+		.cmd = "rotary-encoder",
+		.cmdAlias = "rot",
+		.helpText = "Get current rotary encoder value",
+		.usageText = "",
+		.cmdFct = shell_cmd_rot,
 		.next = NULL,
 	}
 };
 
-shellmatta_handle_t shell_init(void)
+shellmatta_handle_t shell_init(shellmatta_write_t write_func)
 {
 	shellmatta_handle_t handle;
 	shellmatta_retCode_t ret;
 
 	ret = shellmatta_doInit(&shell, &handle, shell_buffer, sizeof(shell_buffer), history_buffer, sizeof(history_buffer),
-			  "\e[1;32mEnter command:\e[m\r\n", cmd, write_shell_callback);
+				"\e[1;32mEnter command:\e[m\r\n", cmd, write_func);
 	if (ret != SHELLMATTA_OK)
 		handle = NULL;
 
@@ -286,10 +334,10 @@ shellmatta_handle_t shell_init(void)
 
 void shell_handle_input(shellmatta_handle_t shell, const char *data, size_t len)
 {
-	 if (!shell)
-		 return;
+	if (!shell)
+		return;
 
-	 shellmatta_processData(shell, (char *)data, (uint32_t)len);
+	shellmatta_processData(shell, (char *)data, (uint32_t)len);
 }
 
 void shell_print_string(shellmatta_handle_t shell, const char *string)

stm-firmware/shellmatta

@@ -1 +1 @@
-Subproject commit 4dc6cd1e79be4fed928443b91de70699773f7084
+Subproject commit 6c76dfc7aed2594579f09d0b797d6a51cffff343

stm-firmware/stack-check.c

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

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

@@ -8,7 +8,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
- * GDSII-Converter is distributed in the hope that it will be useful,
+ * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.

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

@@ -8,7 +8,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
- * GDSII-Converter is distributed in the hope that it will be useful,
+ * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
@@ -33,6 +33,19 @@
 #include <stdbool.h>
 #include <string.h>
 
+static size_t calculate_ring_buffer_fill_level(size_t buffer_size, size_t get_idx, size_t put_idx)
+{
+	size_t fill_level;
+
+	if (put_idx >= get_idx) {
+		fill_level = (put_idx - get_idx);
+	} else {
+		fill_level = buffer_size - get_idx + put_idx;
+	}
+
+	return fill_level;
+}
+
 static int dma_ring_buffer_switch_clock_enable(uint8_t base_dma, bool clk_en)
 {
 	int ret_val;
@@ -141,6 +154,19 @@ void dma_ring_buffer_periph_to_mem_stop(struct dma_ring_buffer_to_mem *buff)
 	memset(buff, 0, sizeof(struct dma_ring_buffer_to_mem));
 }
 
+int dma_ring_buffer_periph_to_mem_fill_level(struct dma_ring_buffer_to_mem *buff, size_t *fill_level)
+{
+	size_t put_idx;
+
+	if (!buff || !fill_level)
+		return -1000;
+
+	put_idx = buff->buffer_count - buff->dma->NDTR;
+	*fill_level = calculate_ring_buffer_fill_level(buff->buffer_count, buff->get_idx, put_idx);
+
+	return 0;
+}
+
 int dma_ring_buffer_mem_to_periph_initialize(struct dma_ring_buffer_to_periph *dma_buffer, uint8_t base_dma_id, DMA_Stream_TypeDef *dma_stream, size_t buffer_element_count, size_t element_size, volatile void *data_buffer, uint8_t dma_trigger_channel, void *dest_reg)
 {
 	if (!dma_buffer || !dma_stream || !data_buffer || !dest_reg)
@@ -163,19 +189,6 @@ int dma_ring_buffer_mem_to_periph_initialize(struct dma_ring_buffer_to_periph *d
 	return 0;
 }
 
-static size_t calculate_ring_buffer_fill_level(size_t buffer_size, size_t get_idx, size_t put_idx)
-{
-	size_t fill_level;
-
-	if (put_idx >= get_idx) {
-		fill_level = (put_idx - get_idx);
-	} else {
-		fill_level = buffer_size - get_idx + put_idx;
-	}
-
-	return fill_level;
-}
-
 static void queue_or_start_dma_transfer(struct dma_ring_buffer_to_periph *buff)
 {
 	uint32_t dma_transfer_cnt;
@@ -289,4 +302,14 @@ void dma_ring_buffer_mem_to_periph_stop(struct dma_ring_buffer_to_periph *buff)
 	memset(buff, 0, sizeof(struct dma_ring_buffer_to_periph));
 }
 
+int dma_ring_buffer_mem_to_periph_fill_level(struct dma_ring_buffer_to_periph *buff, size_t *fill_level)
+{
+	if (!buff || !fill_level)
+		return -1000;
+
+	*fill_level = calculate_ring_buffer_fill_level(buff->buffer_count, buff->dma_get_idx_current, buff->sw_put_idx);
+
+	return 0;
+}
+
 /** @} */

stm-firmware/stm-periph/uart.c

@@ -8,7 +8,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
- * GDSII-Converter is distributed in the hope that it will be useful,
+ * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
@@ -25,99 +25,192 @@
 #include <stm-periph/dma-ring-buffer.h>
 #include <string.h>
 
-static struct dma_ring_buffer_to_mem ring_buff_rx;
-static struct dma_ring_buffer_to_periph ring_buff_tx;
-static char uart_rx_buffer[64];
-static char uart_tx_buffer[256];
-
-#ifdef DEBUGBUILD
-static inline void uart_gpio_config()
+int uart_init(struct stm_uart *uart)
 {
-	rcc_manager_enable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(UART_PORT_RCC_MASK));
-	UART_PORT->MODER &=  MODER_DELETE(UART_TX_PIN) & MODER_DELETE(UART_RX_PIN);
-	UART_PORT->MODER |= ALTFUNC(UART_RX_PIN) | ALTFUNC(UART_TX_PIN);
-	SETAF(UART_PORT, UART_RX_PIN, UART_RX_PIN_ALTFUNC);
-	SETAF(UART_PORT, UART_TX_PIN, UART_TX_PIN_ALTFUNC);
-}
-#endif
+	int ret_val = 0;
+	uint32_t cr3 = 0;
+	uint32_t cr1 = 0;
 
-void uart_init_with_dma()
-{
-	rcc_manager_enable_clock(&RCC->APB2ENR, BITMASK_TO_BITNO(UART_RCC_MASK));
-#ifdef DEBUGBUILD
-	uart_gpio_config();
-#endif
-	UART_PERIPH->BRR = UART_BRR_REG_VALUE;
-	UART_PERIPH->CR3 = USART_CR3_DMAR | USART_CR3_DMAT;
-	UART_PERIPH->CR1 = USART_CR1_TE | USART_CR1_RE | USART_CR1_UE;
+	if (!uart)
+		return -1000;
 
-	dma_ring_buffer_periph_to_mem_initialize(&ring_buff_rx, 2, UART_RECEIVE_DMA_STREAM, sizeof(uart_rx_buffer), 1U,
-						 uart_rx_buffer, (char *)&UART_PERIPH->DR, 4);
-	dma_ring_buffer_mem_to_periph_initialize(&ring_buff_tx, 2, UART_SEND_DMA_STREAM, sizeof(uart_tx_buffer), 1U,
-						 uart_tx_buffer, 4U, (void *)&UART_PERIPH->DR);
+	rcc_manager_enable_clock(uart->rcc_reg, uart->rcc_bit_no);
 
-	NVIC_EnableIRQ(DMA2_Stream7_IRQn);
+	/* Reset all config regs */
+	uart->uart_dev->CR1 = uart->uart_dev->CR2 = uart->uart_dev->CR3 = 0UL;
+
+	/* Set baud rate */
+	uart->uart_dev->BRR = uart->brr_val;
+
+	/* If DMA buffers are present, configure for DMA use */
+	if (uart->dma_rx_buff && uart->rx) {
+		cr3 |= USART_CR3_DMAR;
+
+		ret_val = dma_ring_buffer_periph_to_mem_initialize(&uart->rx_ring_buff,
+								uart->base_dma_num,
+								uart->dma_rx_stream,
+								uart->rx_buff_count,
+								1U,
+								uart->dma_rx_buff,
+								(char *)&uart->uart_dev->DR,
+								uart->dma_rx_trigger_channel);
+		if (ret_val)
+			return ret_val;
+	}
+
+	if (uart->dma_tx_buff && uart->tx) {
+		ret_val = dma_ring_buffer_mem_to_periph_initialize(&uart->tx_ring_buff,
+							 uart->base_dma_num,
+							 uart->dma_tx_stream,
+							 uart->tx_buff_count,
+							 1U,
+							 uart->dma_tx_buff,
+							 uart->dma_tx_trigger_channel,
+							 (void *)&uart->uart_dev->DR);
+		if (ret_val)
+			return ret_val;
+
+		cr3 |= USART_CR3_DMAT;
+	}
+	uart->uart_dev->CR3 = cr3;
+
+	if (uart->tx)
+		cr1 |= USART_CR1_TE;
+	if (uart->rx)
+		cr1 |= USART_CR1_RE;
+
+	/* Enable uart */
+	cr1 |= USART_CR1_UE;
+	uart->uart_dev->CR1 = cr1;
+
+	return 0;
 }
 
-void uart_disable()
+void uart_change_brr(struct stm_uart *uart, uint32_t brr)
 {
-	UART_PERIPH->CR1 = 0;
-	UART_PERIPH->CR2 = 0;
-	UART_PERIPH->CR3 = 0;
-	dma_ring_buffer_periph_to_mem_stop(&ring_buff_rx);
-	dma_ring_buffer_mem_to_periph_stop(&ring_buff_tx);
-#ifdef DEBUGBUILD
-    rcc_manager_disable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(UART_PORT_RCC_MASK));
-#endif
-	rcc_manager_disable_clock(&RCC->APB2ENR, BITMASK_TO_BITNO(UART_RCC_MASK));
+	if (!uart || !uart->uart_dev)
+		return;
+
+	uart->brr_val = brr;
+	uart->uart_dev->BRR = brr;
 }
 
-void uart_send_char(char c)
+void uart_disable(struct stm_uart *uart)
 {
-	while(!(UART_PERIPH->SR & USART_SR_TXE));
-	UART_PERIPH->DR = c;
+	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_array(const char *data, uint32_t len)
+void uart_send_char(struct stm_uart *uart, char c)
+{
+	if (!uart || !uart->uart_dev)
+		return;
+
+	while(!(uart->uart_dev->SR & USART_SR_TXE));
+	uart->uart_dev->DR = c;
+}
+
+void uart_send_array(struct stm_uart *uart, const char *data, uint32_t len)
 {
 	uint32_t i;
 
 	for (i = 0; i < len; i++)
-		uart_send_char(data[i]);
+		uart_send_char(uart, data[i]);
 }
 
-void uart_send_string(const char *string)
+void uart_send_string(struct stm_uart *uart, const char *string)
 {
 	int i;
 
 	for (i = 0; string[i] != '\0'; i++)
-		uart_send_char(string[i]);
+		uart_send_char(uart, string[i]);
 }
 
-void uart_send_array_with_dma(const char *data, uint32_t len)
+void uart_send_array_with_dma(struct stm_uart *uart, const char *data, uint32_t len)
 {
-	dma_ring_buffer_mem_to_periph_insert_data(&ring_buff_tx, data, len);
+	if (!uart || !uart->dma_tx_buff)
+		return;
+
+	dma_ring_buffer_mem_to_periph_insert_data(&uart->tx_ring_buff, data, len);
 }
 
-void uart_send_string_with_dma(const char *string)
+void uart_send_string_with_dma(struct stm_uart *uart, const char *string)
 {
 	size_t len;
 
 	len = strlen(string);
-	uart_send_array_with_dma(string, (uint32_t)len);
+	uart_send_array_with_dma(uart, string, (uint32_t)len);
 }
 
-int uart_receive_data_with_dma(const char **data, size_t *len)
+int uart_receive_data_with_dma(struct stm_uart *uart, const char **data, size_t *len)
 {
-	return dma_ring_buffer_periph_to_mem_get_data(&ring_buff_rx, (const volatile void **)data, len);
+	if (!uart)
+		return -1000;
+
+	return dma_ring_buffer_periph_to_mem_get_data(&uart->rx_ring_buff, (const volatile void **)data, len);
 }
 
-void DMA2_Stream7_IRQHandler()
+char uart_get_char(struct stm_uart *uart)
 {
-	uint32_t hisr = DMA2->HISR;
-	DMA2->HIFCR = hisr;
+	if (!uart)
+		return 0;
+	/* Wait for data to be available */
+	while (!(uart->uart_dev->SR & USART_SR_RXNE));
 
-	if (hisr & DMA_HISR_TCIF7) {
-		dma_ring_buffer_mem_to_periph_int_callback(&ring_buff_tx);
-	}
+	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

@@ -8,7 +8,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
- * GDSII-Converter is distributed in the hope that it will be useful,
+ * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.

stm-firmware/syscalls.c

@@ -8,7 +8,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
- * GDSII-Converter is distributed in the hope that it will be useful,
+ * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
@@ -23,6 +23,7 @@
 #include <errno.h>
 #include <stddef.h>
 
+extern struct stm_uart shell_uart;
 
 char* _sbrk(int incr)
 {
@@ -87,6 +88,17 @@ int _read(void)
 int _write(int fd, const void *buf, int count)
 {
 	if (fd == 1)
-		uart_send_array_with_dma((char*)buf, count);
+		uart_send_array_with_dma(&shell_uart, (char *)buf, count);
 	return count;
 }
+
+int _getpid()
+{
+	return 0;
+}
+
+int _kill(int pid)
+{
+	return -1;
+}
+

stm-firmware/systick.c

@@ -8,7 +8,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
- * GDSII-Converter is distributed in the hope that it will be useful,
+ * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
@@ -41,6 +41,11 @@ void systick_wait_ms(uint32_t ms)
 	while (wait_tick_ms < ms);
 }
 
+uint64_t systick_get_global_tick()
+{
+	return global_tick_ms;
+}
+
 /**
  * @brief Interrupt Handler for SysTick
  *

stm-firmware/temp-converter.c

@@ -8,7 +8,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
- * GDSII-Converter is distributed in the hope that it will be useful,
+ * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.