typedef struct TEST_S
{
    unsigned char start;
    unsigned int length;
    char *text;
}TEST;

extern TEST tests[MAX_TESTS];

unsigned int TESTER_SaveTest(unsigned int user_page)
{
    unsigned int ret;
    unsigned int  addr;
    
    tests[0].start = 0xDA;
    tests[0].length = 5;
    tests[0].text = "HELLO";
    
    tests[1].start = 0xDA;
    tests[1].length = 6;
    tests[1].text = "WORLD!";
    
    ret = FLASH_PageErase(user_page);
    if (ret)
        return ret;
    
    addr = 0;
    ret = FLASH_PageProgram(user_page, addr, (uint8_t *) &tests[0], BUFFER_SIZE_BYTE);
    if (ret)
        return ret;
    
    addr += (sizeof(tests[0])) + 1;
    ret = FLASH_PageProgram(user_page, addr, (uint8_t *) &tests[1], BUFFER_SIZE_BYTE); //тут я получаю ошибку - 32.
    if (ret)  
        return ret;
    
    return ret;
}

FlashProgram(&flashSSDConfig, dest, size, buffer, FlashCommandSequence);

uint32_t SIZE_OPTIMIZATION FlashProgram(PFLASH_SSD_CONFIG pSSDConfig, \
uint32_t dest, \
uint32_t size, \
uint8_t* pData, \
pFLASHCOMMANDSEQUENCE pFlashCommandSequence)
{
uint32_t ret = FTFx_OK; /* return code variable */
uint8_t i;
uint32_t temp;

if (size & (PGM_SIZE_BYTE - 0x01U))
{
ret = FTFx_ERR_SIZE;
}
else
{
/* convert to byte address */
dest = WORD2BYTE(dest);
#if (DEBLOCK_SIZE)
temp = WORD2BYTE(pSSDConfig->DFlashBlockBase);
if((dest >= temp) && (dest < (temp + pSSDConfig->DFlashBlockSize)))
{
dest = dest - temp + 0x800000U;
}
else
#endif
{
temp = WORD2BYTE(pSSDConfig->PFlashBlockBase);
if((dest >= temp) && (dest < (temp + pSSDConfig->PFlashBlockSize)))
{
dest -= temp;
}
else
{
ret = FTFx_ERR_ACCERR;
}
}
while((size > 0x0U) && (FTFx_OK == ret))
{
/* clear RDCOLERR & ACCERR & FPVIOL flag in flash status register. Write 1 to clear*/
temp = pSSDConfig->ftfxRegBase + FTFx_SSD_FSTAT_OFFSET;
REG_WRITE(temp, FTFx_SSD_FSTAT_ERROR_BITS);
/* passing parameter to the command */
#if (PGM_SIZE_BYTE == FTFx_PHRASE_SIZE)
temp = pSSDConfig->ftfxRegBase + FTFx_SSD_FCCOB0_OFFSET;
REG_WRITE(temp, FTFx_PROGRAM_PHRASE);
#else
temp = pSSDConfig->ftfxRegBase + FTFx_SSD_FCCOB0_OFFSET;
REG_WRITE(temp, FTFx_PROGRAM_LONGWORD);
#endif
temp = pSSDConfig->ftfxRegBase + FTFx_SSD_FCCOB1_OFFSET;
REG_WRITE(temp, GET_BIT_16_23(dest));
temp = pSSDConfig->ftfxRegBase + FTFx_SSD_FCCOB2_OFFSET;
REG_WRITE(temp, GET_BIT_8_15(dest));
temp = pSSDConfig->ftfxRegBase + FTFx_SSD_FCCOB3_OFFSET;
REG_WRITE(temp, GET_BIT_0_7(dest));

for (i = 0x0U; i < PGM_SIZE_BYTE; i++)
{
temp = pSSDConfig->ftfxRegBase + i + 0x08U;
REG_WRITE(temp, *(pData + i));
}

/* calling flash command sequence function to execute the command */
ret = pFlashCommandSequence(pSSDConfig);

/* update destination address for next iteration */
dest += PGM_SIZE_BYTE;
/* update size for next iteration */
size -= PGM_SIZE_BYTE;
/* increment the source address by 1 */
pData += PGM_SIZE_BYTE;
}
}
#if C90TFS_ENABLE_DEBUG
/* Enter Debug state if enabled */
if (TRUE == (pSSDConfig->DebugEnable))
{
ENTER_DEBUG_MODE;
}
#endif

return(ret);
}

/* update size for next iteration */
   size -= PGM_SIZE_BYTE;

#define PGM_SIZE_BYTE  0x0008U     /* 8 bytes */

#pragma pack(8)
typedef  struct TEST_S
{
    unsigned char start;
    unsigned int length;
    char *text;
}TEST;

#pragma pack(8)
typedef struct TEST_S
{
    unsigned char start;
    unsigned int length;
    char *text;
}TEST;

typedef
#pragma pack(8)
struct TEST_S
{
    unsigned char start;
    unsigned int length;
    char *text;
}TEST;

status = FLASH_Init();
status = FLASH_PageErase(250);
status = FLASH_PageProgram(250, 0, "hello", BUFFER_SIZE_BYTE);
  
uint8_t buff[5];
#define FLASH_PARAM_ADDR (0x00000000U + (250 * 0x00001000U))
memcpy(&buff, (uint8_t*)FLASH_PARAM_ADDR, 5);

typedef struct TEST_S
{
    unsigned char start;
    unsigned int length;
    char *text;
}TEST;

extern TEST tests[MAX_TESTS];

void TESTER_AddTest(const char *test)
{
    if (test_idx < MAX_TESTS)
    {
        memcpy (tests[test_idx].text, test, strlen(test));
        test_idx++;
    }
    else
        test_idx = 0;
}

char *test_str = malloc(sizeof(char) *  (strlen(str) + padding_size));

typedef struct PackedStr {
  unsigned int length;
  unsigned char tag;
  char string[1];
} PackedStr;

#define BUF_SIZE 1024
char buffer[BUF_SIZE];

PackedStr* get_next(PackedStr* str)
{
  int len = sizeof(str)-1+str->length;
  if (len&-sizeof(int)) len=(len&-sizeof(int))+sizeof(int); // Align for 'int' field
  return (PackedStr*)(len+(char*)str);
}

PackedStr* start = (PackedStr*)buffer;

void write_string(char* your_string, char tag)
{
  start->tag = tag;
  start->length = strlen(your_string);
  memcpy(start->string,your_string,start->length);

  start = get_next(start);

  int len = (char*)start - buffer;
  if ( len >= PGM_SIZE_BYTE)
  {
     int page_aligned = len&-PGM_SIZE_BYTE;
     WriteToFlash(buffer,page_aligned);
     len &= PGM_SIZE_BYTE-1;
     if (len) memcpy(buffer,buffer+page_aligned,len);
     start = (PackedStr*)(buffer+len);
  }
}

void final_flush()
{
  if ((char*)start != buffer)
  {
    ... pad buffer with 0 ...
    WriteToFlash(buffer,PGM_SIZE_BYTE);
    start = (PackedStr*)buffer;
  }
}

typedef struct TEST_S
{
    unsigned int start;
    unsigned int length;
    unsigned int text_addr;
    unsigned int padding; //for padint to 8 bytes
}TEST;

TEST test;

uint32_t struct_size = sizeof(TEST);  //16 bytes
test.start = 0xDADA;
test.length = total_len;      
test.text_ptr = 0;
tests[test_idx].padding = 0;

flash_addr = 0;  //from the start of the page -> 0x000FA000, USER_PAGE = 250
ret = FLASH_PageProgram(USER_PAGE, flash_addr, (uint8_t*) &test,  struct_size);
if (ret)
  return ret;