The first thing to look for when you get this kind of "I change some random other thing and it starts/stops working" behaviour is some kind of memory corruption. Check the limits on all your loops, double check memory allocation/deallocation (if you're using it, which on a microcontroller you probably don't want to), make sure every pointer is initialized properly. Chances are, your allocating and freeing the array changes the layout of the rest of your data in memory in just the right way so that whatever bad memory access is happening now happens to some less important memory.

Onto the code... You probably want to change allocCharBuffer() so that it allocates and initializes (numberOfChars+1) bytes, not (numberOfChars) bytes, to make room for the terminating NUL character at the end of the string. My guess is your code is crashing when you call atoi() on an unterminated string.

When you allocate your string, this causes your next allocCharBuffer() to land in some other chunk of memory which, chances are, is already initialized with zeroes, which is why it works in this case (for a while).

It looks like inputBufferLength is starting out at zero. And then allocCharBuffer(inputBufferLength) gets called which calls malloc with a length of zero. I guess malloc returns the pointer anyway. Yep I just tested it and it does on my system too.

Here's some junk about it: https://bytes.com/topic/c/answers/578467-what-malloc-0-should-returns

You're making assumptions about memory layout and allocation that are not valid. The result of malloc on a size of 0 is undefined. Don't do it. Exactly which region of memory malloc will allocate is also undefined. Don't make assumptions. You're doing both of these things. Allocate a global buffer and reuse that buffer obviously first nulling and ensuring that the buffer is large enough to handle your data. Don't repeatedly allocate and free. Don't make assumptions about what memory is allocated.

Assuming you want to add in more complex stuff, you also might want to check out LEX/YACC. Great tools for lexical analysis and execution in C.

edit Important note to add. Just because your code functions in one environment in C does not mean your code works. Your code in this project does not work. It assumes the result of a malloc of 0 which means the code is broken. Whether or not it gives you the right output for one specific scenario in one specific environment is immaterial to the question.

Some things I noticed

1) You should be able to use calloc to allocate memory and zero it, so you don't have to loop and set it all to zero.

2) I'm not quite sure what you're trying to do here, but I don't think atoi(inputBufferSubset) does what you think it does. If you want the value at inputBufferSubset[0] then you need to do *inputBufferSubset. In which case, you could just do char position = *inputBufferSubset; If you need the value of multiple chars, you'll need to combine the bytes into an integer. (int)*inputBufferSubet would work, but it would include the junk after the value. In this case you would need the length and mask it or bitshift. Alternatively, put the value into a zeroed char[] coinCount; and do (int)*coinCount. EDIT: I may be wrong with with this point. I tested it real quickly and it always returned 0..but in retrospect it should have worked.

3) positionCountArray = allocIntBuffer(8); requestArray = allocIntBuffer(8); There's probably more code than what is here, but hopefully you are freeing these at some point.

I would write the code totally differently:

#define US 31
void getToken(char* input, unsigned int inputLength, char* result, unsigned int* resultLength) 
{   
    int i = 0;
    for(; i < inputLength; i++) {
        if(input[i] == US) {
               break;
        }
    }
    *resultLength = i;
    memcpy(result, input, i);
}
void main(...) {
    char input[8] = {48, 31, 49, 31, 49, 48, 31, 30};
    int inputLength = 8; // Not going to use strlen because no \0
    char token[8] = {}; // results can never be longer than the input
    int resultLength = 0;
    int index = 0;
   // Get motor
   getToken(&input[index], inputLength, token, &resultLength);
   int motor = token[0];
   index += resultLength + 1;
   // Get second unit (ASCII 49)
   getToken(&input[index], inputLength-index, token, &resultLength);
   int secondUnit = token[0];
  index += resultLength + 1;
  // Get quantity
  getToken(&input[index], inputLength-index, token, &resultLength);
  int coinCount = (int)*token & 0x0000FFFF; // Don't forget about endianness!
     and bitshift to get the integer value. I can't imagine someone would want > 99 coins, but who knows. */
 // etc...
}

It's really rough, incomplete, and probably broken but I think you get the idea. Your really should try to avoid calling malloc & free so many times. Eventually the memory will become fragmented and memory allocation will fail. Hopefully this helps.