AVR Freaks

This is a test program but should demonstrate how to do;

#include <avr/io.h>

void writePageOfBytes(uint32_t, const uint8_t*, uint16_t);

//Machine Vars For Save/Restore
struct MachVars {
    uint8_t save_valid;                  // marks if the save flash has been written
    unsigned long slope[9];           // slope corrections
    unsigned long offset[9];          // offset corrections
    unsigned int seq[9];       // Main preset setting
    unsigned int encseq[9];    // Stores offsets from encoder
    uint8_t gateseq[9];           // Stores offsets from encoder
} saves;

    uint8_t buf[155];

int main(void)
{
    int i = 0;
    
    saves.save_valid = 1;
    for (i = 0; i < 9; i++)
    {
        saves.slope[i] = 0x32 + i;
        saves.offset[i] = 0x33 + i;
        saves.seq[i] = 0x34 + i;
        saves.encseq[i] = 0x35 + i;
    }
    
    // the call to save to flash
    writePageOfBytes(0, (uint8_t*) &saves, sizeof(saves));

    i = 32;
    
    while(1)
    {
        //TODO:: Please write your application code
    }
}

    void writePageOfBytes(uint32_t addr, const uint8_t* pbuf, uint16_t len) {
        for (uint16_t i = 0; i < len; i++)
        {
            buf[i] = *pbuf++;
        }
    }

What you are really trying to do here is called serialization. If it has to be divided up into chunks I would do something like:

struct MachVars {
  byte save_valid;                  // marks if the save flash has been written
  unsigned long slope[9];           // slope corrections
  unsigned long offset[9];          // offset corrections
  unsigned int seq[8][64][8];       // Main preset setting
  unsigned int encseq[8][64][8];    // Stores offsets from encoder
  byte gateseq[8][64][8];           // Stores offsets from encoder
} saves;

div_t sizeData;

int main(void) {
    uint8_t * p;
    int n, page;
    sizedata = div(sizeof(saves), 256);
    p = (uint8_t *)&saves;
    page = 0;
    for (n = 0; n < sizeData.quot; n++) {
        writePageOfByes(page++, p, 256);
        p += 256;
    }
    if (sizeData.rem) {
        writePageOfByes(page, p, sizeData.rem);
    }
}

Which will write n full 256 byte pages and then one last page of the "spillage" into the last page (if any).

I had to guess what the first 0 in writePageOfBytes() was - I assume it is an incrementing page number rather a byte address? If it is a byte address then page++ is not enough and would need to be brought out as "page += offset;"