Top  Previous  Next

With booting we mean starting up like when you power a PC, after a reset.

When you reset the processor your user code will be executed.

A boot loader is a small program which task it is to re-program the processor. That is : in our case. A boot loader could do security checks or have other functions but when we say boot loader it always refer to some code that will reprogram the processor.


A boot loader typically runs just after a reset. But it could be initiated on any possible way. The recommended way is to use the statement : RESET MICRO.


A normal AVR and Xmega have a fuse that can be set to select the reset vector. It can point to address 0 which is the normal start address. Or it can point to an address at the end of flash memory.

When the fuse points to the boot vector, a jump is executed to this memory. And the boot code that is located at this memory is executed. Typically it will receive data and will flash/reprogram the memory from address 0 and up.

After that, the code at address 0 is executed and the normal user code runs.

The $LOADER directive is used to place the program code at the boot address at the end of memory. The exact address depends on other fuse settings and the processor used.

The normal user code always end up in location 0 and up.



The new Xtiny/MegaX and AVRX processors work different. A reset will always execute address 0. But when you want to program a boot loader, you use a Boot fuse to tell how big the boot loader is. A value of 1 will reserve a size of 512 bytes. A value of 2 will reserve 1024 bytes, etc. So you are flexible in selecting the size of the boot loader.

After the boot block your normal code starts. But now you see the difference : the normal user code runs at a higher address. So we must tell the compiler that all code must be relocated.

We use the $ROMSTART directive for that.


A boot loader does not have a $ROMSTART directive.

While the boot fuse uses blocks of 512 bytes, the flash page size can be different. Do not confuse this. AVRX processors typically have flash page size of 512 bytes.




For the AVRX series we include here a sample boot loader.


'                          (c) 1995-2023, MCS
'                        Bootloader-AVRX.bas
'  This sample demonstrates how you can write your own bootloader
'  in BASCOM BASIC for the AVR DB/DA series
' The AVRX has a different memory lay out and a different NVM controller
' Normal AVR starts with normal application code and the boot code is placed at the end of memory.
' AVRX starts with BOOT memory. So we always start in BOOT mode.
' With the BOOTEND fuse we can set the size of the BOOT area.
' Different processors have different page sizes. For DA/DB series the pages size is 512 bytes
'  A value of 1 will give a size of 512 bytes, a value of 2 gives 1024 bytes, etc.
'  In this example we use less than 1536 bytes so we set the fuse to 3.
' Notice that the fuse page size can differ from the flash page size ! In this case the sizes are equal.
' After the optional boot space there is the APPLICATION CODE
' And after the APPLICATION CODE there is the APPLICATION DATA
' When you dont want a boot loader you set the bootend fuse to 0 which is the default.
'  your app will use the boot and application code
' When you want a boot loader, you determine the size of the boot loader and then
'  set the fuse to the proper size
' With the MCS boot loader, the code simply checks if the #123 data is received.
' If so, it starts the loading. If not it continues.
' It is similar to the normal AVR boot loading. The normal AVR boot starts after the normal space.
' # There is one important difference. With normal AVR all the code start at &H0000.
'   For the loader we then use the $LOADER directive to place the code at the proper address
' For XTINY/AVRX the boot loader starts at &H0000 thus is considered a normal application without specific switches
' Your normal code must now be located AFTER the bootloader. This means you need to instruct the compiler to place the code
' at a different address. We use $ROMSTART for this purpose.
' Remember that AVR has word address. Which means that each address uses 2 bytes of memory.
$regfile ="AVRX128da28.dat"
$crystal = 24000000
$hwstack = 40
$swstack = 40
$framesize = 40
'declare subs and functions
Declare Sub Erasepage()
Declare Sub Protected_write_spm(byreg R16 As Byte)
'The AVRX series have more oscillator options
Config Osc = Enabled , Frequency = 24mhz
'set the system clock and prescaler
Config Sysclock = Int_osc , Prescale = 1
'define the baud rate and port/usart
Config Com1 = 115200 , Mode = Asynchroneous , Parity = None , Databits = 8 , Stopbits = 1
Const Pagesize_bts = 512                                   ' page size in bytes is 512 bytes
Const Fword = Pagesize_bts / 2                             ' page size in words is 256
Const Numpages = 256                                       ' number of page is 256
Const Key_ctrla_spm = &H9D                                 ' ccp key write protect for SPM NVM_CTRLA
Const Key_ctrlb_io = &HD8                                   ' ccp key write protect for IO  NVM_CTRLB
' NVM Commands
Const Nocmd = 0                                             'no command
Const Noop = 1                                             'no operation
Const Flwr = 2                                             'flash write enable
Const Flper = 8                                             'flash erase enable
'flash constants
Const Maxwordbit = 8
Const Maxword =(2 ^ Maxwordbit) * 2                         '512
Const Maxwordshift = Maxwordbit + 1                         '9
'It is VERY IMPORTANT that the baud rate match the one of the boot loader
'do not try to use buffered com since we do not use interrupts
'you could however use interrupts but it occupies more space
'Possible return codes of the PC bootloader.exe
' -6005    Cancel requested
' -6006    Fatal time out
' -6007    Unrecoverable event during protocol
' -6008    Too many errors during protocol
' -6009    Block sequence error in Xmodem
' -6016    Session aborted
'since this is a boot loader we do not want a vector table
'we reduce the vector table to 0
'Dim the used variables
Dim Z As Dword                                             ' this is the Z pointer word
Dim Vl As Byte , Vh As Byte                                 ' these bytes are used for the data values
Dim Wrd As Word , Page As Word                             ' these vars contain the page and word address
Dim Bstatus As Byte , Bretries As Byte , Bblock As Byte , Bblocklocal As Byte
Dim Bcsum1 As Byte , Bcsum2 As Byte , Buf(128) As Byte , Csum As Byte
Dim J As Byte , Wptr As Word
'We start with receiving a file. The PC must send this binary file
'some constants used in serial com
Const Cnak = &H15
Const Cack = &H06
$timeout = 400000                                           ' we use a timeout
'When you get LOADER errors during the upload, increase the timeout value
'for example at 16 Mhz, use 200000
Bretries = 5                                               ' we try 5 times
  Bstatus = Waitkey()                                     ' wait for the loader to send a byte
  Print Chr(bstatus);                                     ' echo back
  If Bstatus = 123 Then                                   ' did we received value 123 ?
    Goto Loader                                           ' jump into boot loader
  End If
  Decr Bretries
Loop Until Bretries = 0
'if we arrive here, there was not boot character received. we simply continue
Goto Application_start_noload                               ' goto the normal code
'this is the loader routine. It is a Xmodem-checksum reception routine
     Bstatus = Waitkey()                                   ' flush the data
  Loop Until Bstatus = 0
'just like the normal AVR loader we need to erase  a page first
'but since we write beyond the loader we need to set the page to the proper value which is essential the same as the FUSE BOOT SIZE value !
  page=3 'remember each page uses 512 bytes, this code is less than 1536 so the normal app start on page 3
  Erasepage                                               'erase it
  Bretries = 10                                           ' number of retries
     Bblocklocal = 1
     Csum = 0                                             ' checksum is 0 when we start
    Print Chr(cnak);                                     ' first time send a nack
        Bstatus = Waitkey()                               ' wait for status byte
        Select Case Bstatus
          Case 1:                                         ' start of heading, PC is ready to send
              Csum = 1                                     ' checksum is 1
              Bblock = Waitkey() : Csum = Csum + Bblock   ' get block
              Bcsum1 = Waitkey() : Csum = Csum + Bcsum1   ' get checksum first byte
              For J = 1 To 128                             ' get 128 bytes
                 Buf(j) = Waitkey() : Csum = Csum + Buf(j)
              Bcsum2 = Waitkey()                           ' get second checksum byte
              If Bblocklocal = Bblock Then                 ' are the blocks the same?
                If Bcsum2 = Csum Then                     ' is the checksum the same?
                    Gosub Writepage                       ' yes go write the page
                    Print Chr(cack);                       ' acknowledge
                    Incr Bblocklocal                       ' increase local block count
                Else                                     ' no match so send nak
                    Print Chr(cnak);
                End If
                Print Chr(cnak);                         ' blocks do not match
              End If
          Case 4:                                             ' end of transmission , file is transmitted
          '  Waitms 100                                   ' OPTIONAL REMARK THIS IF THE DTR SIGNAL ARRIVES TO EARLY
              Print Chr(cack);                             ' send ack and ready
              Waitms 20
              Goto Application_start                       ' start new program
          Case &H18:                                     ' PC aborts transmission
              Goto Application_start                       ' ready
          Case 123 : Exit Do                             ' was probably still in the buffer
          Case Else
              Exit Do                                     ' no valid data
        End Select
    If Bretries > 0 Then                                 ' attempte left?
        Waitms 1000
        Decr Bretries                                     ' decrease attempts
        Exit Do                                           ' reset chip
    End If
  Protected_write_SPM nocmd                               ' clear current command
  Cpu_ccp = key_CTRLB_io
  Rstctrl_swrr = 1                                         ' perform a soft reset
'no code between the label above and below !
  r23=&B111                                               ' set value
  Cpu_ccp = key_CTRLB_io                                   ' configuration change protect
  Nvmctrl_ctrlb = R23                                     ' enable boot section read protect, appdatawrite protect, appcode protect
  'the addres to go to is a word address, since our loader is less than 1536 bytes, this is 600 in hex and divided by 2 for words gives 300
  Goto &H300                                               ' normal app code
'this sub routine will write the pages
  For J = 1 To 128 step 2                                 ' get 128 bytes
     Z = Page                                             ' make equal to page
    Shift Z , Left , Maxwordshift                       ' shift to proper place
     Z = Z + Wrd                                         ' add word
     r0= Buf(j)                                           ' r0:r1 point to the DATA for SPM
     R1 = Buf(j + 1)
    ! lds r30,{Z}                                           ; Z points to address
    ! lds r31,{Z+1}
    #if _romsize > 65536
        ! lds r24,{Z+2}
        ! sts rampz,r24                                     ' we need to set rampz also for 128KB chips
    !spm                                                   ; this actual executes the instruction
     wrd=wrd+2                                             ' we write word data so increase by 2
  if wrd=maxword then                                     ' page is full
     wrd=0                                               ' reset word counter for next page
     page=page+1                                         ' increase page
     Erasepage                                             ' erase so we can write
  end if
'erase a page based on PAGE value
'RAMPZ ZH  ZL (bit0 for low high byte selection)
'          7 bits for word address : 128 word address
'          1 bit from ZH -> 256 word address
'  leves 7 bit for PAGE address
Sub Erasepage()
  Z = Page                                                 ' make equal to page
  Shift Z , Left , Maxwordshift                             ' shift to proper place
  bitwait NVMCTRL_STATUS.0,reset                           ' make sure flash is not busy
  Protected_write_SPM nocmd                                 ' clear current command
  Protected_write_SPM flper                                 ' erase page enable
  'dummy write needed, how dum
  ! lds r30,{Z}
  ! lds r31,{Z+1}
  #if _romsize > 65536
    ! lds r24,{Z+2}
    ! sts rampz,r24                                       ' we need to set rampz also for 128KB chips
  ! clr r0                                                   ; data must be 0 for the dummy write
  ! clr r1
  !spm                                                     ; execute dummy write
  bitwait NVMCTRL_STATUS.0,reset                           ' make sure flash is not busy
  Protected_write_SPM nocmd                                 ' clear current command
  Protected_write_SPM flwr                                 ' enable write to flash
end sub
sub Protected_write_SPM(byreg r16 as byte)
  CPU_CCP= key_CTRLA_spm                                   'change protect key
  NVMCTRL_CTRLA=r16                                         'write to SPM register
end sub
'this loader takes less than 1536 bytes so the BOOT FUSE is set to 3.
'do NOT FORGET that your normal app must use $ROMSTART=&H300 in that case  : halve of the bytes size of the loader
'one other thing : the reset pin works in UPDI mode by default. so your chip will not reset when you do not change the fuse
'but there are other ways of reset such as soft reset, bod and wd.



You compile the code and from the report you can find that the code size is 1214 bytes. Because the boot fuse block is 512, it means the value must be : 1214/512=2.31 We round up so end with 3.


We now run the MCS UPDI programmer and select the fuses TAB




The boot section size must be set to 3 as shown above.

You can also use the WRITE CONFIG button to write a CONFIG FUSE line in your code.

Just make sure the editor is set to a new line. in this case we end up with :


Config Fuses = Off , Lock = Off , Fuse0 = &H00 , FUSE1 = &H20 , FUSE2 = &HF0 , FUSE5 = &HDA , FUSE6 = &HF8 , FUSE7 = &H00 , FUSE8 = &H03 , UROW0 = &H00 , UROW31 = &H31


All user row values with a non default value are included too.


When you compile with CONFIG FUSES=OFF, nothing will happen. Only when you change the FUSES=OFF to FUSES=ON, the fuses will be programmed when you auto program the chip.

And when you change LOCK=OFF to LOCK=ON, the processor will be locked too. The lock will make sure the data can not be read any longer. only the UNLOCK chip option from the programmer can unlock the chip. An operation that will also erase the chip. So typically writing LOCK bytes is something you do when all is tested.


Once we have programmed our boot loader and set the boot fuse to the correct size, we can use the MCS Boot loader to load new code.

Do not forget to chose the MCS Boot loader.


The only thing you need to remember : include the $ROMSTART=&H300 line in your NORMAL code.

Most examples you find do not have this directive.


Instead of the MCS Bootloader you can also make a boot loader that use Blue Tooth, Wifi, or an SD card.

The mechanism is always : at boot check some condition, when met, perform the update.


The actual boot loader will remain in the processor.

When you have suitable hardware like an external EEPROM with the size of the FLASH memory, you could update the firmware in your normal code. The boot code then would copy from EEPROM when required.


A boot loader could use decryption so your firmware can not be easily disassembled.