Weird correlation between I2C Transfer and Array size

Question

So... i don't even know how to explain this...

I have a cc1310 Launchpad XL and a tiny EEPROM. My task is to write a library for easy transferring. In Code Composer Studio I'm using an Example project from TI with TIRTOS to test my functions. The weird thing is:

when i am declaring a uint8_t array larger than 304. my Transactions wont work. Itll only send 1 Byte and freezes. Under 305, everything is fine. Oh and im not even using the array. It just has to exist and nothing works.

void *mainThread(void *arg0)
{
  uint32_t *pAddress;
  int i;
  uint8_t dat = 0;
  uint32_t address = 0x00FEAA;
  uint8_t data[305] = {0};
  uint32_t datalen = sizeof(data);

  for(i=0; i< 305; i++)
  {
    data[i]=dat;
    dat++;
  }

  pAddress=&address;
  int write =  EEPROM_sWrite(pAddress, data,datalen);
  return 0;
}

and

int EEPROM_sWrite(uint32_t *address, uint8_t *data, uint32_t datalen)
{
  I2C_init();

  //needed variables and initialization
  uint8_t writebuf[258] = {0};
  uint8_t blocksize = 0;
  uint8_t *p = &writebuf[2];

  if((*address+datalen)>maxAddress) //out of bounds?
  {
    return 1;
  }
  else
  {

    I2C_Transaction Transaction = {0};
    Transaction.slaveAddress = slaveAddressA;
    Transaction.writeBuf = writebuf;
    Transaction.writeCount = blocksize;
    Transaction.readBuf = NULL;
    Transaction.readCount =0;

    I2C_Params params;
    I2C_Params_init(&params);
    params.bitRate = I2C_400kHz;
    params.transferMode = I2C_MODE_BLOCKING;

    I2C_Handle Handle = I2C_open(0,&params );

    //first block
    if(*address>0xFFFF) //second half of the memory?
    {
      Transaction.slaveAddress = slaveAddressB;
    }

    blocksize =  maxPagesize - (*address & 0xFF)+1; 
    //blocksize needs to be adjusted to the page size

    writebuf[0] = (*address & 0xFF00) >> 8;      //page address
    writebuf[1] = (*address & 0xFF);        //cell Address

    if(datalen<=blocksize) //if it fits in a single page, just do it
    {
      memcpy(p,data,datalen);
      //copies data to buffer (fills only needed cells in page)
      Transaction.writeCount = datalen+2;

      if(I2C_transfer(Handle, &Transaction))
      {
        I2C_close(Handle);
        return 0;
      }
      else
      {
        I2C_close(Handle);
        return 1;
      }
    }

    memcpy(p,data,blocksize);//copies data to buffer (fills complete page)
    Transaction.writeCount = blocksize+2;

    if(!I2C_transfer(Handle, &Transaction))
    {
      I2C_close(Handle);
      return 1;
    }
    usleep(10000);

    //loop preparation
    data+=blocksize;//shifts pointer forward
    datalen-=blocksize; //reduces blocksize
    writebuf[0]++; //next page
    writebuf[1] = 0; //start cell is now 0 each time

    //nth block
    while(datalen>maxPagesize) //cut down to page sized blocks and write it down
    {
      //copy 256 bytes of data to buffer
      memcpy(p,data,maxPagesize);

      //send it
      Transaction.writeCount = maxPagesize+2;
      if(!I2C_transfer(Handle, &Transaction))
      {
        I2C_close(Handle);
        return 1;
      }
      usleep(10000);

      //preparation
      data+=maxPagesize;
      datalen-=maxPagesize;

      //checks if it exceeds the first memory half
      if(writebuf[0]==0xff)
      {
        Transaction.slaveAddress=slaveAddressB;
        writebuf[0]=0;
      }
      else
      {
        writebuf[0]++; //next page
      }
    }

    //last block

    //copy last data
    memcpy(p,data,datalen);

    //send it
    Transaction.writeCount = datalen+2;
    if(!I2C_transfer(Handle, &Transaction))
    {
      I2C_close(Handle);
      return 1;
    }
    I2C_close(Handle);
    return 0;
  }
}

edit: #define maxAddress 0x1FFFF #define maxPagesize 0xFF

forgot them..

Answer 1

A Reddit user had the right idea!

Turns out it was a simple stack overflow. The Stack size of the thread was 1024. As i changed it to 2048, everything works.