Question: Serial programming procedure of ATMEGA328PB

[blauertee]

Hello!
I would like to know how the general paged programming procedure works for the ATMEGA328PB. I have to write a programmer myself since I have to use a specific SPI interface or let's say the C# abstraction of that. I tried to figure these questions out starring at your source code, but it's just to complex of a project to be a quick help for me.

If no one has the time to help right now or this is too off topic just close this. :)

Is my understanding of the general Programming sequence that I got from the Datasheet right and if not where did I take the wrong turn?

(I'm using byte indices instead of words so the page size would by 128 bytes, and when I say byte index I mean relative to all the data I want tow write to the flash)

• Put the MCU into programming mode
• Write each Page by sending:
  • Write each byte of the page by sending:
    • INST[0] = 0x48, if the index of the byte even (Load Program Memory Page, Low byte)
    • INST[0] = 0x40, if the index of the byte is odd (Load Program Memory Page, High byte)
    • INST[1] = 0x0
    • INST[2] = the index of the byte relative to the current page divided by two (adr LSB)
    • INST[3] = the data byte (high/low data byte in)
  • send the write Instruction:
    • INST[0] = 0x4C (Write Program Memory Page)
    • INST[1] = byte index devided by two >> 8 (adr MSB)
    • INST[2] = byte index devided by two & 0xff
    • INST[3] 0x0
  • Poll RDY/BSY until Ready

If anyone find's any time to help I'd be grateful! Thx!

[mcuee]

For question like this, please use Discussion.

[stefanrueger]

SPI

Looks like you want Serial Programming. And yes, the datasheet you pointed to is your friend. Page 346ff, in particular the table on page 348. The note (8) for write page does not exist, but I reckon it's a typo for note (6). In the write page instruction you must send the words address of any one 16-bit word in the page (customarily the first word of the page). The page load needs the word address bits within the page.

[blauertee]

EDIT: Completely misunderstood, don't read.

Thanks!

So I've learned that for every word, I want to write, I need to send these three instructions:

• Load Program Memory Page, Low byte
• Load Program Memory Page, High byte
• Write Program Memory Page

Does this mean that the Write Program Memory Page Instruction writes word at LSB within the page to the absolute address MSB, LSB in the flash? (MSB, LSB) = (pageIndex, adressWithinthePage)
I'm a little confused by the Page only having 6 address bits but the main flash having a byte.
Should it be (MSB, LSB) = (pageIndex >> 2, adressWithinthePage | (pageIndex << 6)?

[stefanrueger]

You can only program a page (128 bytes) at once: first one loads the 128 bytes of a page using the 2 different load page commands in alternation, then you write the 128-byte page once with write page. Here how avrdude composes the SPI commands for flash:

$ avrdude -p ATmega328PB/S
[...]
    memory "flash"
        paged              = yes;
        size               = 0x8000;
        page_size          = 128; 
        num_pages          = 256; 
        min_write_delay    = 4500;
        max_write_delay    = 4500;
        mode               = 0x41;
        delay              = 10;
        blocksize          = 128;
        readsize           = 256;
        read_lo            = "0010.0000--00aa.aaaa--aaaa.aaaa--oooo.oooo";
        read_hi            = "0010.1000--00aa.aaaa--aaaa.aaaa--oooo.oooo";
        loadpage_lo        = "0100.0000--000x.xxxx--xxaa.aaaa--iiii.iiii";
        loadpage_hi        = "0100.1000--000x.xxxx--xxaa.aaaa--iiii.iiii";
        writepage          = "0100.1100--00aa.aaaa--aaxx.xxxx--xxxx.xxxx";
    ;
[...]

Good luck with rolling your own.

[blauertee]

Thank's a lot, I got it to work. I'm just gonna share some pseudo code here, for anyone who is as confused as I was when starring at the Data Sheet or the avrdude source code.

(Pseudocode is ChatGPT generated from real code, cuz I can not post the former since I don't own it and don't have the time to write it myself.)

function ATMEGA328PBProgramFlash(fileData):
    constant pageSizeBytes = 128
    pageCount = roundUp(fileData.length / pageSizeBytes)
    loadHighByteInstruction = [0x48, 0x00, 0x00, 0x00]
    loadLowByteInstruction = [0x40, 0x00, 0x00, 0x00]
    writePageInstruction = [0x4C, 0x00, 0x00, 0x00]

    for pageIndex from 0 to pageCount - 1:
        startOffset = pageIndex * pageSizeBytes


        for byteIndex from 0 to pageSizeBytes - 1 step 2:
            wordAddressWithinPage = byteIndex / 2


            if (startOffset + byteIndex) < fileData.length:
                dataLowByte = fileData[startOffset + byteIndex]
            else:
                dataLowByte = 0xFF
            
            if (startOffset + byteIndex + 1) < fileData.length:
                dataHighByte = fileData[startOffset + byteIndex + 1]
            else:
                dataHighByte = 0xFF
            

            loadLowByteInstruction[2] = wordAddressWithinPage 
            loadLowByteInstruction[3] = dataLowByte
            spiPort.writeReadParallel(null, loadLowByteInstruction, 0, 4)

            loadHighByteInstruction[2] = wordAddressWithinPage 
            loadHighByteInstruction[3] = dataHighByte
            spiPort.writeReadParallel(null, loadHighByteInstruction, 0, 4)

        absoluteAddressMSB = pageIndex >> 2
        absoluteAddressLSB = (pageIndex << 6) & 0xFF

        writePageInstruction[1] = absoluteAddressMSB
        writePageInstruction[2] = absoluteAddressLSB
        spiPort.writeReadParallel(null, writePageInstruction, 0, 4)
        ATMEGA328PBPollReadyBusy()