Uso de free () en la programación del microcontrolador PIC

free () siempre se usa en combinación con malloc (). Ambos se refieren a la memoria dinámica en el montón. Si observa la sección 5.5.7 de la Guía del usuario del compilador XC8 C :

  

La asignación de memoria dinámica, (asignación basada en heap con malloc , etc.) no es compatible con ningún dispositivo de 8 bits. Esto se debe a la cantidad limitada de memoria de datos y a que esta memoria está almacenada en un banco. La naturaleza inútil de la asignación de memoria dinámica no se adapta a las arquitecturas de dispositivos PIC de 8 bits.

Si establece el nivel de optimización correcto, alto (suponiendo que tiene la versión estándar / pro del compilador), el compilador puede ver cuándo ya no se necesita la memoria y reescribirla si es necesario. Esto solo es posible si su código no es demasiado complicado.

Con un bajo nivel de optimización, el compilador no lo reconocerá y la variable se comportará normalmente, su memoria se liberará cuando la función en la que es una variable local regrese (como ocurre con todas las variables en la pila). Si esto está en la función main () o estamos hablando de una variable global, eso significa que nunca.

Solo necesita la memoria free() que se ha asignado dinámicamente (por ejemplo, con malloc ). Nada de eso se aplica a XC8, que yo sepa.

En cualquier caso, con el código que publicaste, no asignaste ninguna memoria dinámica, por lo que no es necesario liberarla.

Actualice su pregunta para mostrar la implementación de returnarray y enmendaré mi respuesta si es necesario.

Si necesita implementar una asignación estilo malloc en el PIC u otro microcontrolador pequeño, hay algunas maneras de hacerlo. Lo más sencillo es definir:

#define POOL_SIZE 100 // Or however big it can be without running out of space

uint8_t mem_pool[POOL_SIZE];
#define pool_end (mem_pool+POOL_SIZE)
uint8_t *next_alloc;
void *malloc(uint8_t size)
{
  if (pool_end - next_alloc <= size)
  {
    uint8_t *ret = next_alloc;
    next_alloc += size;
    return ret;
  }
  else
    return 0;
}
void release(uint8_t *dat)
{
  next_alloc = dat;
}

Liberar cualquier objeto liberaría ese objeto y todo lo que se liberó después de él . En los casos en que esto coincida con la semántica deseada, el código anterior sería mucho más barato que admitir la asignación y liberación de memoria en una secuencia arbitraria. Si se pueden dividir las asignaciones en dos grupos y decir que es aceptable que la liberación de un objeto también libere todos los demás objetos en el mismo grupo , eso simplemente requiere que pool_end sea un uint8_t * variable, y luego agregar:

void *umalloc(uint8_t size)
{
  if (pool_end - next_alloc <= size)
  {
    pool_end -= size;
    return pool_end;
  }
  else
    return 0;
}
void urelease(uint8_t *dat, uint8_t size)
{
  pool_end = dat+size;
}

Tenga en cuenta que a la función urelease , a diferencia de release , se le debe indicar el tamaño del bloque que se asignó, pero la sobrecarga total para estos enfoques será de 2 bytes si se usa solo malloc/release y 4 bytes si utilizando umalloc/urelease , sin sobrecarga por bloque adicional .

Si uno necesita asignar y liberar bloques en una secuencia arbitraria, es posible que un PIC lo admita, pero hacerlo agregará complejidad y puede resultar en una fragmentación de la memoria. Si por ejemplo uno tiene un grupo de 512 bytes y asigna 16 elementos cuyos tamaños son alternativamente 27 + 1 bytes y 3 + 1 bytes (27 o 3 bytes de datos, más un encabezado de un byte) y uno libera todos los 27 + 1 bytes elementos, a uno le quedarían 448 bytes, pero no tienen espacio que pueda contener 28 bytes de datos. Si se puede trabajar con las limitaciones del grupo de doble terminación que se muestra arriba, dicho diseño tendrá una sobrecarga mínima y requerirá un código mínimo para su uso, pero permitirá que la memoria se divida entre diferentes propósitos en tiempo de ejecución.

No he visto la función free () en el microcontrolador. Creo que si envuelve su código en una función, la memoria se liberará tan pronto como la función regrese (el alcance de las variables entra en acción).