Arduino Playground - AvailableMemory

Available Memory

Note: For Arduino 1.0, you have to replace #include <WProgram.h> with #include <Arduino.h>.

The microcontrollers used on Arduino boards (ATmega8, ATmega168 and ATmega328) have a small amount of RAM.

In order to determine the amount of memory currently available the most accurate result can be found by using this MemoryFree library. It is based on code posted in the forum (here), extended to include walking the free list:

MemoryFree.h:

// MemoryFree library based on code posted here:
// http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1213583720/15
//
// Extended by Matthew Murdoch to include walking of the free list.

#ifndef MEMORY_FREE_H
#define MEMORY_FREE_H

#ifdef __cplusplus
extern "C" {
#endif

int freeMemory();

#ifdef __cplusplus
}
#endif

#endif

[Get Code]

MemoryFree.cpp:

#if (ARDUINO >= 100)
#include <Arduino.h>
#else
#include <WProgram.h>
#endif

extern unsigned int __heap_start;
extern void *__brkval;

/*
* The free list structure as maintained by the
* avr-libc memory allocation routines.
*/
struct __freelist {
size_t sz;
struct __freelist *nx;
};

/* The head of the free list structure */
extern struct __freelist *__flp;

#include "MemoryFree.h";

/* Calculates the size of the free list */
int freeListSize() {
struct __freelist* current;
int total = 0;

for (current = __flp; current; current = current->nx) {
total += 2; /* Add two bytes for the memory block's header */
total += (int) current->sz;
}

return total;
}

int freeMemory() {
int free_memory;

if ((int)__brkval == 0) {
free_memory = ((int)&free_memory) - ((int)&__heap_start);
} else {
free_memory = ((int)&free_memory) - ((int)__brkval);
free_memory += freeListSize();
}
return free_memory;
}

[Get Code]

Example sketch:

#include <MemoryFree.h>

// On Arduino Duemilanove with ATmega328:
//
// Reported free memory with str commented out:
// 1824 bytes
//
// Reported free memory with str and Serial.println(str) uncommented:
// 1810
//
// Difference: 14 bytes (13 ascii chars + null terminator)

// 14-bytes string
//char str[] = "Hello, world!";

void setup() {
Serial.begin(115200);
}

void loop() {
//Serial.println(str);

Serial.print("freeMemory()=");
Serial.println(freeMemory());

delay(1000);
}

[Get Code]

Other simpler functions that compute how much memory you have free (but use dynamic allocation and deallocation of memory which may not be ideal):

// this function will return the number of bytes currently free in RAM
// written by David A. Mellis
// based on code by Rob Faludi http://www.faludi.com
int availableMemory() {
  int size = 1024; // Use 2048 with ATmega328
  byte *buf;

  while ((buf = (byte *) malloc(--size)) == NULL)
    ;

  free(buf);

  return size;
}

Here is an alternative function:

/* This function places the current value of the heap and stack pointers in the
 * variables. You can call it from any place in your code and save the data for
 * outputting or displaying later. This allows you to check at different parts of
 * your program flow.
 * The stack pointer starts at the top of RAM and grows downwards. The heap pointer
 * starts just above the static variables etc. and grows upwards. SP should always
 * be larger than HP or you'll be in big trouble! The smaller the gap, the more
 * careful you need to be. Julian Gall 6-Feb-2009.
 */
uint8_t * heapptr, * stackptr;
void check_mem() {
  stackptr = (uint8_t *)malloc(4);          // use stackptr temporarily
  heapptr = stackptr;                     // save value of heap pointer
  free(stackptr);      // free up the memory again (sets stackptr to 0)
  stackptr =  (uint8_t *)(SP);           // save value of stack pointer
}

Note: For my 2K ATMega328 system, the first simpler function gave me bogus random results and caused the system to hang. The second gave me consistent and I think accurate results.

Another method that seems to be even simpler is the following:

Declare this function:

int freeRam () {
  extern int __heap_start, *__brkval; 
  int v; 
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval); 
}

and call it anywhere in your program like that: Serial.println(freeRam());

In my test the results were quite similar with the first method, the one that uses the library. I found this function here: http://www.controllerprojects.com/2011/05/23/determining-sram-usage-on-arduino/

Share|