malloc()
em microcontroladores é geralmente considerado uma "coisa ruim". Mas, se você absolutamente precisar, encontrará uma versão de terceiros.
Se você tiver sorte, o código que você está portando pode não depender da reutilização de blocos de memória. Se for esse o caso, você pode escrever um alocador simples que retorne um ponteiro para um buffer de RAM e avance o ponteiro pelo tamanho do bloco solicitado.
Eu já usei essa abordagem com êxito antes na transferência de bibliotecas de PC para microcontroladores.
Abaixo, você configuraria o alocador my_malloc_init()
e alocaria memória com my_malloc()
. my_free()
existe para satisfazer a dependência, mas na verdade não faz nada. Eventualmente, você ficará sem espaço, é claro.
Para fazer isso funcionar, você precisará medir o pior requisito de memória do seu código (faça isso em um PC, se possível) e configurar de HEAP_SIZE
acordo. Antes de entrar na parte da sua biblioteca que requer memória dinâmica, ligue my_malloc_init()
. Antes de reutilizar, verifique se ainda não há nada apontado heap
.
uint8_t heap[HEAP_SIZE];
uint8_t *heap_ptr;
void my_malloc_init(void)
{
heap_ptr = heap;
}
void *my_malloc(size_t len)
{
uint8_t *p = heap_ptr;
heap_ptr += len;
if (heap_ptr >= heap + HEAP_SIZE)
return NULL;
else
return p;
}
void my_free(void)
{
// do nothing
}
(nota: no mundo real, pode ser necessário considerar o alinhamento do ponteiro, ou seja, arredondar para heap_ptr
2 ou 4 bytes)
Outra opção é usar uma estrutura de alocação mais simples do que malloc()
normalmente é fornecida, como uma FreeList , embora isso possa não permitir a alocação de blocos de tamanho variável.