#define STM_VERSION // Replace sane LD symbols with STM CubeMX's poor standard exported LD symbols

#define ISR_STACK_LENGTH_BYTES (configISR_STACK_SIZE_WORDS*4) // bytes to reserve for ISR (MSP) stack

#include <stdlib.h> // maps to newlib...

#include <malloc.h> // mallinfo...

#include <errno.h> // ENOMEM

#include <stdbool.h>

#include <stddef.h>

#include "newlib.h"

#if ((__NEWLIB__ == 2) && (__NEWLIB_MINOR__ < 5)) ||((__NEWLIB__ == 3) && (__NEWLIB_MINOR__ > 1))

#warning "This wrapper was verified for newlib versions 2.5 - 3.1; please ensure newlib's external requirements for malloc-family are unchanged!"

#include "FreeRTOS.h" // defines public interface we're implementing here

#if !defined(configUSE_NEWLIB_REENTRANT) || (configUSE_NEWLIB_REENTRANT!=1)

#warning "#define configUSE_NEWLIB_REENTRANT 1 // Required for thread-safety of newlib sprintf, dtoa, strtok, etc..."

// If you're *REALLY* sure you don't need FreeRTOS's newlib reentrancy support, comment out the above warning...

#include "task.h"

#if 0

caddr_t _sbrk(int incr)

{

extern char end asm("end"); // From linker: lowest unused RAM address, just beyond end of BSS.

static char *heap_end;

char *prev_heap_end;

if (heap_end == 0) heap_end = &end;

prev_heap_end = heap_end;

if (heap_end + incr > stack_ptr) // Fails here: always true for FreeRTOS task stacks

{

errno = ENOMEM; // ...so first call inside a FreeRTOS task lands here

return (caddr_t) -1;

}

heap_end += incr;

return (caddr_t) prev_heap_end;

}

register char * stack_ptr asm("sp");

#ifdef STM_VERSION // Use STM CubeMX LD symbols for heap+stack area

// To avoid modifying STM LD file (and then having CubeMX trash it), use available STM symbols

// Unfortunately STM does not provide standardized markers for RAM suitable for heap!

// STM CubeMX-generated LD files provide the following symbols:

// end /* aligned first word beyond BSS */

// _estack /* one word beyond end of "RAM" Ram type memory, for STM32F429 0x20030000 */

// Kludge below uses CubeMX-generated symbols instead of sane LD definitions

#define __HeapBase end

#define __HeapLimit _estack // In K64F LD this is already adjusted for ISR stack space...

static int heapBytesRemaining;

// no DRN HEAP_SIZE symbol from LD... // that's (&__HeapLimit)-(&__HeapBase)

uint32_t TotalHeapSize; // publish for diagnostic routines; filled in first _sbrk call.

// Note: DRN's K64F LD provided: __StackTop (byte beyond end of memory), __StackLimit, HEAP_SIZE, STACK_SIZE

// __HeapLimit was already adjusted to be below reserved stack area.

extern char HEAP_SIZE; // make sure to define this symbol in linker LD command file

static int heapBytesRemaining = (int)&HEAP_SIZE; // that's (&__HeapLimit)-(&__HeapBase)

#ifdef MALLOCS_INSIDE_ISRs // STM code to avoid malloc within ISR (USB CDC stack)

// We can't use vTaskSuspendAll() within an ISR.

// STM's stunningly bad coding malpractice calls malloc within ISRs (for example, on USB connect function USBD_CDC_Init)

// So, we must just suspend/resume interrupts, lengthening max interrupt response time, aarrggg...

#define DRN_ENTER_CRITICAL_SECTION(_usis) { _usis = taskENTER_CRITICAL_FROM_ISR(); } // Disables interrupts (after saving prior state)

#define DRN_EXIT_CRITICAL_SECTION(_usis) { taskEXIT_CRITICAL_FROM_ISR(_usis); } // Re-enables interrupts (unless already disabled prior taskENTER_CRITICAL)

#define DRN_ENTER_CRITICAL_SECTION(_usis) vTaskSuspendAll(); // Note: safe to use before FreeRTOS scheduler started, but not in ISR

#define DRN_EXIT_CRITICAL_SECTION(_usis) xTaskResumeAll(); // Note: safe to use before FreeRTOS scheduler started, but not in ISR

#ifndef NDEBUG

static int totalBytesProvidedBySBRK = 0;

extern char __HeapBase, __HeapLimit; // symbols from linker LD command file

void * _sbrk_r(struct _reent *pReent, int incr) {

#ifdef MALLOCS_INSIDE_ISRs // block interrupts during free-storage use

UBaseType_t usis; // saved interrupt status

#endif

static char *currentHeapEnd = &__HeapBase;

#ifdef STM_VERSION // Use STM CubeMX LD symbols for heap

if(TotalHeapSize==0) {

TotalHeapSize = heapBytesRemaining = (int)((&__HeapLimit)-(&__HeapBase))-ISR_STACK_LENGTH_BYTES;

};

#endif

char* limit = (xTaskGetSchedulerState()==taskSCHEDULER_NOT_STARTED) ?

stack_ptr : // Before scheduler is started, limit is stack pointer (risky!)

&__HeapLimit-ISR_STACK_LENGTH_BYTES; // Once running, OK to reuse all remaining RAM except ISR stack (MSP) stack

DRN_ENTER_CRITICAL_SECTION(usis);

if (currentHeapEnd + incr > limit) {

// Ooops, no more memory available...

#if( configUSE_MALLOC_FAILED_HOOK == 1 )

{

extern void vApplicationMallocFailedHook( void );

DRN_EXIT_CRITICAL_SECTION(usis);

vApplicationMallocFailedHook();

}

#elif defined(configHARD_STOP_ON_MALLOC_FAILURE)

// If you want to alert debugger or halt...

// WARNING: brkpt instruction may prevent watchdog operation...

while(1) { __asm("bkpt #0"); }; // Stop in GUI as if at a breakpoint (if debugging, otherwise loop forever)

#else

// Default, if you prefer to believe your application will gracefully trap out-of-memory...

pReent->_errno = ENOMEM; // newlib's thread-specific errno

DRN_EXIT_CRITICAL_SECTION(usis);

#endif

return (char *)-1; // the malloc-family routine that called sbrk will return 0

}

// 'incr' of memory is available: update accounting and return it.

char *previousHeapEnd = currentHeapEnd;

currentHeapEnd += incr;

heapBytesRemaining -= incr;

#ifndef NDEBUG

totalBytesProvidedBySBRK += incr;

#endif

DRN_EXIT_CRITICAL_SECTION(usis);

return (char *) previousHeapEnd;

}

char * sbrk(int incr) { return _sbrk_r(_impure_ptr, incr); }

char * _sbrk(int incr) { return sbrk(incr); };

#ifdef MALLOCS_INSIDE_ISRs // block interrupts during free-storage use

static UBaseType_t malLock_uxSavedInterruptStatus;

void __malloc_lock(struct _reent *r) {

#if defined(MALLOCS_INSIDE_ISRs)

DRN_ENTER_CRITICAL_SECTION(malLock_uxSavedInterruptStatus);

#else

bool insideAnISR = xPortIsInsideInterrupt();

configASSERT( !insideAnISR ); // Make damn sure no more mallocs inside ISRs!!

vTaskSuspendAll();

#endif

};

void __malloc_unlock(struct _reent *r) {

#if defined(MALLOCS_INSIDE_ISRs)

DRN_EXIT_CRITICAL_SECTION(malLock_uxSavedInterruptStatus);

#else

(void)xTaskResumeAll();

#endif

};

void __env_lock() { vTaskSuspendAll(); };

void __env_unlock() { (void)xTaskResumeAll(); };

#if 1 // Provide malloc debug and accounting wrappers

/// /brief Wrap malloc/malloc_r to help debug who requests memory and why.

/// To use these, add linker options: -Xlinker --wrap=malloc -Xlinker --wrap=_malloc_r

// Note: These functions are normally unused and stripped by linker.

size_t TotalMallocdBytes;

int MallocCallCnt;

static bool inside_malloc;

void *__wrap_malloc(size_t nbytes) {

extern void * __real_malloc(size_t nbytes);

MallocCallCnt++;

TotalMallocdBytes += nbytes;

inside_malloc = true;

void *p = __real_malloc(nbytes); // will call malloc_r...

inside_malloc = false;

return p;

};

void *__wrap__malloc_r(void *reent, size_t nbytes) {

extern void * __real__malloc_r(size_t nbytes);

if(!inside_malloc) {

MallocCallCnt++;

TotalMallocdBytes += nbytes;

};

void *p = __real__malloc_r(nbytes);

return p;

};

void *pvPortMalloc( size_t xSize ) PRIVILEGED_FUNCTION {

void *p = malloc(xSize);

return p;

}

void vPortFree( void *pv ) PRIVILEGED_FUNCTION {

free(pv);

};

size_t xPortGetFreeHeapSize( void ) PRIVILEGED_FUNCTION {

struct mallinfo mi = mallinfo(); // available space now managed by newlib

return mi.fordblks + heapBytesRemaining; // plus space not yet handed to newlib by sbrk

}

void vPortInitialiseBlocks( void ) PRIVILEGED_FUNCTION {};