I forgot to mention that the new character array that is created, is deleted in my main function. As far as I know there is no memory leak and the function runs indefinitely, if there were a leak it would only run 4 times as there is only 40k RAM dynamically available.

How do you use the local packet_data pointers in the main (how do you delete them)?
I don't think it's a good idea to return pointers declared and initialized in a function as local and use them in the main. There is no guarantee that the pointer remains valid outside the function's scope (it's rather a coincidence, if it happens).

How does std::string version perform?

using std::string is going to require a rework of the code as the strcat function requires a char array since it is a C function as opposed to a c++ function. The way I understand it, if you create a pointer to an object in the heap, and pass that pointer back to a main function it should hold it just fine, which it does consistently because heap memory isn't local to functions. I use the standard delete[] packet_data; to delete a char array.

Basically you are right. But my concern is about the pointer itself.
I think if you declare the pointer as global, initialize it in the function and then delete the object (created on the heap in the function's body) in the main, it should work.

string* packet_data;    // declare as global pointer (you can use it for deleting the object it point to (for example in the main or other function)

string* make_packet(float* float_array, char* time)
{
    //Create a string *(stream) object to easily format data into JSON format Manually
    stringstream* stream = new stringstream;
    //String to hold and return packet to main
    packet_data = new string;
    //Create start of packet, including message number, and time stamp.
    *(stream) << "{\"mcount\":" << mcount << ","; //begin packet and insert message number.
    *(stream) << "\"timestamp\":\"" << time << "\",\"d\":[";
    //Add all of the data to the packet, append each point to the packet until full desired message length is reached
    //Floats have 3 decimal places
    stream->precision(3);

    for(int i = 0; i<MSG_LEN; i++) {
        //create data points/data numbers
        *(stream) << "{\"p\":" << float_array[i] << ",\"n\":"<< i << "},";
        pc.printf("size of string: %i\n", (stream->str()).size());
    }
    *(stream) << "]}";
    //Turn string stream into a string, finish the packet and return it to main to be sent.
    *(packet_data) = stream->str();
    delete stream;
    pc.printf("packet_data = %s\n", packet_data->c_str());
    return packet_data;
}

int main(void)
{
    ...
    make_packet(..);    // create new packet_data
    ...                 // send packet_data
    delete packet_data;
    ...
}

This is essentially the same as what I'm doing, but does not address my original question, which was that the for loop would stop concatenating at the same point every time, at around the 93rd or so iteration, the program stops concatenating and overwrites the string. Which is happening in the function, not when it is passed back, all of that has worked fine.

Hello Daniel,
I'm sorry but I do not have answer to that question. Maybe someone else will help.
NOTE: On my NUCLEO-F103RB board the for loop throws a runtime error: "Operator new out of memory" after just eight cycles. On the other hand the version with std::string was capable to run hundred iterations with no error.

I tried using the std::string method and it hangs at runtime no error message just stops running. Not sure what that's about.

I'm not sure as well but most likely there is a memory collision. I would recommend you to try the trick proposed by Andy. Seems very efficient.