10 years, 1 month ago.

Dynamic memory allocation is done using malloc(size), it returns a void* to the start of the memory block or null if there isn't enough memory. Call free(pointer) to release the memory when you are finished with it.

These functions are fairly slow to call so avoid using them excessively.

You access the memory from another function by passing that function the pointer to the buffer.

e.g.

unsigned long uart_serial::RFID_RadioRead(BufferedSerial *handle) {

const int bufferSize = 1024; 
char *buffer = (char *) malloc(sizeof(char) * bufferSize);  // allocate memory
if (buffer == NULL) // failed to allocate memory 
  return 0; 

unsigned int bytesRead = readRadio(handle, buffer, bufferSize);
unsigned long totaBytes = 0;

while (bytesRead  > 0)  {  // while there are bytes left
  processBuffer(buffer,bytesRead,totalBytes );    // output them.
  totalBytes += bytesRead;                                   // update the counter
  bytesRead = readRadio(handle, buffer, bufferSize); // get the next set of data                                      
}

free (buffer); // release the memory
return totaBytes ;
}

// read until nothing left or we hit a limit and then return the number of bytes 
unsigned int uart_serial::readRadio(BufferedSerial *handle, char *buffer, unsigned int maxSize) {

unsigned int byteCount = 0;
while (handle->readable() && (byteCount<maxSize)) {
  *buffer = handle->getc();
  buffer++;
}

return byteCount;
}

// output the data in the buffer
uart_serial::processBuffer(char *buffer, unsigned int size, unsigned long priorBytes) {

unsigned int count = 0;
while (count < size) {
  uartSerialDebug.traceOut("buffer[%d]: %02lX = %d \n", priorBytes+count, *buffer, *buffer)
  buffer++;
  count++;
}

}

One potential issue is if you need to process all the data about one tag at the same time then what do you do if you get the data for 4 1/2 tags in your buffer? You can display the first 4 but what about the half a tag of data?

The best way to deal with that is to copy the remaining half tag of data to the start of the buffer and then modify the buffer pointer and max size passed to the read function so that it adds the next byte just after the data you had left, that way you'll get all the data in one block. The simple way is that if each tag takes exactly the same number of bytes make the buffer a multiple of that size so you never get half a tag to start with. Faster and simpler but less flexible.

And one style note, never pass something like a BufferedSerial as a parameter to a function, always pass a pointer to it. Not only does it save a few lines of code it saves a massive amount of memory and CPU time. As a general rule unless it's a primitive built in data type (int, char etc...) always pass a pointer rather than the actual object.