Program Boot Loader Atmega 8

Program boot loader atmega 8

Hardware

Basically AVRUSBBoot can be used with all circuits which are supported by the AVR USB driver. To switch between the bootloader and the application, an aditional jumper is necessary. Here is an example (Here the levels on the data lines are 5V which doesn't meet the USB specification! The supply voltage should be regulated to 3,3V - 3,6V):

;--------------------------------------------------------------------------------------; ; Program: Bootloader_Mega8.asm Bootloader_Mega8.asm ; ; Writer: Herbert Dingfelder, Dingfelder, DL5NEG ; for contact information visit WWW.DL5NEG.DE WWW.DL5NEG.DE ; ; Based on: AVR-Freaks Design Note #32 ; ; Function: Bootloader for ATmega8, Works via the UART with the normal ; AVRProg PC-Software ; ; Hardware: ATmega8 with a 7.3728MHz crystal ; ; History: ; ; 13.07.2004 - Source code adapted for Mega8, assembles without errors ;

; 15.07.2004 - Used crystal is not 7.3 but 3.686 MHz -> UART setting adapted ; - LED on LEDport/LEDbi t is switched on within the boot section, ; tested in Hardware and works -> processor starts correctly ; within the boot section ; 18.07.2004 - Problem how to download the bootloader is solved: Simply use ; the AVRProg in the "mega8" mode, not in "mega8boot" mode. ; Since the Intel-Hex Format contains the address for the code ; in each line, the programmers recognizes that the code has to ; go to the bootrom part of the flash (provide that the ; ".org MY_BOOTSTART " is put at the beginning of the source code) ; - UART communication between bootloader and host PC works ; (echo mode and character recognition recognition tested and works) ; - Crystal changed to 7.3728MHz in an attempt to fight "flushing" ; problems in AVRProg (without success), UART setting adapted ; - AVRProg is able to read the flash correctly (tested, works) ; - Reading and writing to EEPROM on host commands 'D' and 'd' works. ; - Flash erase did not work in the NRWR section (the last 1024 ; words of the flash) The original version from DesignNote #32 ; was for ATmega163 which does not have RWR/NRWR sections. ; Problem solved by implementing the wait_for_spm wait_for_spm function that ; makes sure that a new SPM does only start when the previous one ; is completed. (tested, works now) ; - function to reenable the RWW section implemented -> ; loading data into the application section tested and works fine ; (Still some problems with sync on the interface between AVRProg ; and the boot loader, messagebox "flushing" appears, fuse bits are ; read differently differently many times and software download needs to be ; started twice sometimes. As it is known that AVRProg is very sensible ; command/answer command/answer sync, this does not point towards real bootloader problems. ; It has to be tracked on the interface.) ; -> Good enough to work with temporarily, Version 1.0 released. ; - Startup-func tion implemented for 10 second wait after power-on. If

; no ASCII(27) is received via UART within that time, the application starts. ; If the application section is empty (all cells are $FF) e.g. directly ; after uploading the bootloader itself, then software will wait forever ; for a ESC via the UART to start the bootloader software ; (while waiting for the ESC the LED blinks) ; - Function pause implemented for delays in steps of 10ms (tested works) ; - Command 'E' implemented for leaving the bootloader mode and start the ; application ; - With that entry end exit function the bootloader is fully usable, starting ; the downloaded application is tested and works perfectly ; -> Version 1.1 released ; - Still known problem: the above mentioned sync problem in combination ; with AVRProg have to be identified and solved. ; - Only 2 Words are left in the bootloader memory. If Bugfixing needs more, ; the erease counter within the EEPROM can be skipped ; 24.07.2004 - Debug Session with Andy, DG9NDZ to find why AVRProg 1.37 still has some ; problems with the bootloader, especially in the "Advanced" Window. ; * Command 'v' for Hardware Version was not implemented -> fixed ; * Command ':' for tranparent command setting was not implemented ; -> is now implemented in simple version, always returning \0 ; By monitoring the PC/AVR interface it was found that AVRProg1.37 does ; not use the defined commands r/F/N for reading the lock and fuse bits, ; but uses the universal command ':' to send the programming instructions ; directly. Additionally the calibration byte is read by the ':' command. ; * Command 'b' is send by AVRProg1.37 but is not implemented. It was found that ; it is fatal for the programming mode to implement 'b' to return 'Y', 'Y'. ; To simply leave it out (returns ? for unknow command) works perfectly. ; 25.07.2004 - To implement all improvements found on 24.07.2004 without skipping lots of ; of other code made it necessary to increase the boot loader size to 512words ; (=1kByte). Code adapted. ; - Command ':' enlarged to map r/F/N functionality ; - Tested, current status: Works well in AVRProg both for flash reading and writing

; and also in the Advance window the lock and fuse bits are display correctly. ; Only week point remaining to press "write" in advance window, that causes a ; loose of sync between host and bootloader. No harm is done to the target device. ; -> Version 1.2 released. ; 26.07.2004 - Monitoring of interface from host reveals the root cause of the sync problem when ; writing the the lock and fuse bits. AVRProg1.37 uses the "new universal command" ; which is "." + 4 data bytes. This command was not implemented. As changing the ; fuse bits is dangerous when the device is remote (one could lock himself out ; forever), the command is now implemented simply to ignore the inputs but correctly ; serve the interface to the host to avoid sync problems. Tested and works perfectly. ; -> Version 1.3 release ; ; ; ; Before or after programming a new ATmega8 with this Boot Loader you must program Fuse ; bits as follows: ; ; • The ATmega8 Fuse High bits must be programmed to 0x04 in order to configure ; the Boot size to 256 words and to move the Reset Vector to word address 0x1f00. ; ; I.e. set the check box for BOOTRST in AVR-Prog-Advanced and set the ; selector to 256words, then press "write". It is important that this selected ; size of the bootrom fits to the .org command within this source code, otherwise ; the processor will not correctly start at the first line of this code after reset. ; (Settings can be checked now or later with "read"). ; ; Optional: ; ; • The Lock bits can be programmed to 0xEF to protect the Boot Flash Section from ; unintentional changes and to allow accessing the Application Flash Section. ; ; I.e. the setting for BLB0 and BLB1 in AVR-Prog-Advance: ; ; BLB0 (sets the protection for the application section) must be set to ; Mode 1 (no protection) to allow full access of LPM and SPM commands within ; the application section. ; ; BLB1 (sets the protection for the boot loader section) can be set to Mode 2 ; (SPM cannot write to boot section) or can be left to Mode 1 (no protection).

; ; • The Fuse bits must be programmed before programming bits. ; ; ; AVRProg Commands as defined by Atmel ; ; ; ; Enter Programming Mode ; Auto Increment Address ; Set Address ; Write Program Memory, Low Byte 'c' ; Write Program Memory, High Byte 'C' dd ; Issue Page Write ; Read Lock Bits ; Read Program Memory 'R' ; Read EEPROM Memory ; Write EEPROM Memory ; Chip Erase ; Write Lock Bits ; Read Fuse Bits ; Read High Fuse Bits 'N' ; Read Extended Fuse Bits 'Q' ; Leave Programming Mode ; Select Device Type ; Read Signature Bytes 's' ; Return Supported Device Codes 't' ; Return Software Identifier 'S' ; Return Software Version 'V' ; Return Hardware Version ; Return Programmer Type 'p' ; Set LED ; Clear LED ; Exit Bootloader ; Check Block Support 'b' ; Start Block Flash Load 'F' 13d (not implemented) ; ; Start Block EEPROM Load 'B' ; ; Start Block Flash Read 'F' n*dd (not implemented) ; Start Block EEPROM Read 'g' ; Universal Command (3 data bytes) ':' ; New Universal Command (4 data bytes)'.' ;

the Lock

Host Writes ID 'P' 'a' 'A' dd

dd ah al 13d

'm' 'r'

dd 2*dd

'd' 'D' 'l' 'F'

dd dd 'e' dd dd dd dd

'L' 'T'

dd n*dd

'v' 'x' 'y'

.def uni_cmd1 = r20 ':' send three bytes. These

dd dd dd

'E' 'Y' 2*dd 'B'

2*dd

2*dd 'E' 'g'

13d

2*dd

2*dd 'E' n*dd 3*dd dd 4*dd dd

;-------------------------definition and includes -------------------------------------.INCLUDE "m8def.inc" Definitions for the mega8 .def tmp_r = r18 temporary stuff .def pa_10ms = r19 the pause time in steps of 10ms

3*dd 00d s[7] dd dd

; Include Register/Bit ; Use Reg. R18 for ; used for selecting

; Universal command

13d 13d

.def uni_cmd2 = r21 futher usage in r20, r21, r28 .def uni_cmd3 = r10

; are stored for

.equ VER_H = '1' version higher number .equ VER_L = '3' version lower number

; bootloader software

.equ VERH_H = '1' version higher number .equ VERH_L = '0' version lower number

; bootloader hardware

.equ DT = 0x76 (ATmega8)

; Device Type = 0x76

.equ SB1 = 0x07 .equ SB2 = 0x93 .equ SB3 = 0x1e

; Signature byte 1 ; Signature byte 2 ; Signature byte 3

.equ ESC = 27

; bootloader software

; bootloader hardware

; Ascii 27 = Escape

;LR***************************************************** .equ fCK = 7372800 ;X-tal frequency * .equ BaudR=19200 ;Baud rate * .equ Tr_Sp=0 ;Transmission speed (U2X) * .equ UBR=-1+(5+10*fCK/(16*BaudR-8*BaudR*Tr_Sp))/10 ; * .equ presc=1024 ; * .equ fTmr=100 ;freq. of Timer 0 (1/10ms=100) * .equ TmrLoad=256-(fCK/(presc*fTmr)) ; * .equ CR = 13 ; * ; * ;Pin for LED and Boot escape definition: * .equ LEDport =PORTc ; * .equ LEDdir =DDRc ; * .equ LEDbit =1 ; * ; * .equ TestPort =PINC ; * .equ TestBit =1 ; * ; * .equ ActiveStatLED=0 ;0=low, 1=high active stat * .if ActiveStatLED ; * .macro set_led ; * sbi LEDport,LEDbit ; * .endm ; * ; * .macro clr_led ; * cbi LEDport,LEDbit ; * .endm ; * .else ; * .macro set_led ; * cbi LEDport,LEDbit ; * .endm ; * ; * .macro clr_led ; * sbi LEDport,LEDbit ; * .endm ; * .endif ; * ; *

;LR***************************************************** .equ MY_BOOTSTART = THIRDBOOTSTART starts in the flash

; here we define where the bootloader

;----------------------------- here we go ---------------------------------------------.org MY_BOOTSTART

; bootstart address according to .equ above

; ---------------------------------- Boot Escape ----------------------------------------;LR*********************************** in tmp_r,TestPort ; * sbrc tmp_r,TestBit ; * rjmp FLASHEND+1 ; * ;LR*********************************** ; ----------------------------------- init stackpointer -------------------------------ldi R24, low(RAMEND) ; SP = RAMEND ldi R25, high(RAMEND) out SPL, R24 out SPH, R25 ldi tmp_r, 0b00000101 ; set prescaler to 1024 out TCCR0, tmp_r ; ---------------------------------- init UART ----------------------------------------;LR*********************************** .if Tr_Sp ; * sbi UCSRA,U2x ; * .else ; * cbi UCSRA,U2x ; * .endif ; * ;LR*********************************** ldi tmp_r, LOW(UBR) out UBRRL, tmp_r .if HIGH(UBR) ldi tmp_r, HIGH(UBR) out UBRRH, tmp_r .endif ldi tmp_r,(1<
; Enable receiver &

; -------------------------- check for action on UART ---------------------------------; After power-on, the processor starts with the bootloader section. Ususally the user ; want the application to start automatically. Only in special cases, a software update ; is required. So if no ESC (ASCII(27)) is received within 8 seconds after power-on, ; the application starts. sbi LEDdir, LEDbit LEDport to output to drive an LED ldi R17, 20 number of LED-flashes for the waiting periode

; Switch ; Preset the

start_wait: clr_led rcall pause200 sbic UCSRA,RXC rjmp Char_Rec0 data (if RXC==1) st_wait2: set_led rcall pause200 sbic UCSRA,RXC data (if RXC==1) rjmp Char_Rec1 data (if RXC==1) dec R17

; switch off the LED ; wait a moment ; check for incoming

; switch on the LED ; wait a moment ; check for incoming ; check for incoming

; decremente the loop

counter brne start_wait counter has reached zero clr_led rjmp FLASHEND+1 application program

; and leave loop if ; switch off the LED ; Start the

;--- some character was received --Char_Rec0: set_led ; switch on the LED Char_Rec1: in R16,UDR ; fetch received character and put it into R16 cpi R16, ESC ; if the received character was ESC brne No_ESC ; start the bootloader main loop ;--------------------------------- start of main loop ---------------------------------;-------------------- wait for a character from UART other than ESC -------------------L10: rcall uartGet ; repeat (R16 = uartGet) cpi R16, ESC ; while (R16 == ESCAPE) breq L10 No_ESC: ;--------- Command 'E' leaves the bootloader mode and starts the application -----------cpi R16, 'E' ; if(R16=='E') 'E' = Exit bootloader brne L11 ;LR******************************** ldi R16,CR rcall uartSend TstUDRE: sbis UCSRA,UDRE ; wait for empty transmit buffer (until UDRE==1) rjmp TstUDRE TstTXC: sbis UCSRA,TXC ; wait for USART Transmit Complete (until TXC==1) rjmp TstTXC ;LR******************************** rcall pause200

clr_led rjmp FLASHEND+1 application program

; switch off the LED ; Start the ;

(flashend+1) = Address 0 ;--------- Command 'a' is question from host for autoimcrement capability--------------; simple anser is 'Y' for yes, autoincrement is done L11: cpi R16, 'a' ; if(R16=='a') 'a' = Autoincrement? brne L12 ldi R16,'Y' ; Yes, autoincrement is quicker rjmp L70 ; uartSend(R16) Send the 'Y' and go up for next command

;--------- Command 'A' is setting the address for the next operation ------------------; two bytes (in total) for high and low address are sent from the host L12: cpi R16,'A' ; else if(R16=='A') write address brne L14 rcall uartGet mov R27,R16 is stored in R27

; address high byte

rcall uartGet mov R26,R16 stored in R26

; address low byte is

lsl R26 address=address<<1 rol R27 byte address to word address

;

rjmp L68 uartSend('\r') send CR and go up for next command

;

; convert from

;--------- Command 'c' is write low byte to program memory ----------------------------; the low byte is simply stored in a register, the actual writing to the flashes ; page-buffer is done later, after the high byte was received L14: cpi R16,'c' ; else if(R16=='c') write program memory, low byte brne L16 rcall uartGet written from host mov R22,R16 in R22

; read the byte to be

; store data low byte

rjmp L68 uartSend('\r') send CR and go up for next command

;

;--------- Command 'C' is write high byte to program memory ---------------------------; together with the (already received) low byte, the highbyte is writen to the flashes ; page buffer. When the page buffer is completely written, it can be transfered into ; the real flash by the "page write" command. ; ; If only SPMEN is written, the following SPM instruction will store the value in R1:R0 ; in the temporary page buffer addressed by the Z pointer. L16: cpi R16,'C' write program memory,high byte brne L18

; else if(R16=='C')

rcall uartGet from the host mov R23,R16 byte in R23

; read the high byte ; store the data high

movw ZL,R26 with the current address

; load the Z pointer

movw R0,R22 word (data high and low byte)

; transfer the data ; into

registers R0 and R1 rcall wait_for_spm ready to accept a new task

; make sure SPM is

ldi R24, (1<
; set SPMEN in SPMCR ; page load (fill

spm program memory

; Store

adiw R26,2 address=address+2 rjmp L68 uartSend('\r') send CR and go up for next command

; ;

;-------------------------- Command 'e' is chip erase ---------------------------------; "chip erase" for the boot loader means to erase all flash pages othen than the ; boot loader sector itself L18: cpi R16,'e' Chip erase brne L28

; else if(R16=='e')

; the loop that has to be performed to clear the application section is: ; for(address=0; address < (2*MY_BOOTSTART); address += (2*PAGESIZE)) ; the "address" variable to be used are the registers R26 and R27 clr R26 address 0 clr R27

; start with

rjmp L24 loop at the check for

; continue the ;

"end-criteria reached" ;......... beginning of erase loop ............ L20: ; If the PGERS bit is written to one at the same time as SPMEN, the next SPM ; instruction within four clock cycles executes page erase. The page address ; is taken from the high part of the Z pointer. rcall wait_for_spm ready to accept a new task

; make sure SPM is

movw ZL,R26 with the address of the

; load the Z-pointer ; page

to be erased ldi R24, (1<
; Store

subi R26,low(-2*PAGESIZE) the size of a page sbci R27,high(-2*PAGESIZE)

; increment the address by

; this is the check for end-criteria reached, i.e. has the address already ; reached the beginning of the boot-loader section L24: ldi R24,low( 2*MY_BOOTSTART) where the boot-loader ldi R25,high(2*MY_BOOTSTART)

; load R24, R25 with the address ;

section starts

cp R26,R24 compare to check if the address is still cpc R27,R25 the address where the bootloader starts

; do a word-

brlo L20 the case, go to the beginning of the erase loop

; if that is

; smaller than

; ..... remember the number of flash-erases in the EEPROM ..... ldi R26,low( E2END -1) ; increment Chip Erase Counter located ldi R27,high(E2END -1) ; at address E2END-1 movw R22,R26 ; Save Chip Erase Counter Address in R22 ldi R17,1 ; read EEPROM rcall EepromTalk mov R24,R16 ; R24 = Chip Erase Counter low byte rcall EepromTalk mov R25,R16 ; R25 = Chip Erase Counter high byte adiw R24,1 ; counter ++ out EEDR,R24 ; EEDR = R24 Chip Erase Counter low byte movw R26,R22 ; R26 = Chip Erase Counter Address ldi R17,6 ; write EEPROM rcall EepromTalk out EEDR,R25 ; EEDR = R25 Chip Erase Counter high byte rcall EepromTalk ; .......................................................... rcall wait_for_spm ready to accept a new task

; make sure SPM is

rcall enable_rww RWW section so it can be accessed again

; reenable the

rjmp L68 uartSend('\r') send CR and go up for next command

;

;---------------------------- Command 'm' is write page -------------------------------; To execute page write, set up the address in the Z pointer, write 'X0000101' to SPMCR ; and execute SPM within four clock cycles after writing SPMCR. The data in R1 and R0 ; is ignored. The page address must be written to PCPAGE. Other bits in the Z pointer will ; be ignored during this operation. L28: cpi R16,'m' ; else if(R16== 'm') Write page brne L34 rcall wait_for_spm ready to accept a new task movw ZL,R26

; make sure SPM is

; load Z-pointer with

address ldi R24, (1<
; Store

nop rcall enable_rww RWW section so it can be accessed again

; reenable the

L32: rjmp L68 uartSend('\r') send CR and go up for next command

;

;--------------------- Command 'P' is enter programming mode --------------------------; nothing is done here, only the command is confirmed to host by sending CR L34: cpi R16,'P' ; else if(R16=='P') Enter programming mode breq L32 ; uartSend('\r') Send CR to host and go up for next command

;--------------------- Command 'L' is leave programming mode --------------------------; nothing is done here, only the command is confirmed to host by sending CR cpi R16,'L' ; else if(R16=='L') Leave programming mode breq L32 ; uartSend('\r') Send CR to host and go up for next command

;--------------------- Command 'p' is Return programmer type --------------------------; simply return an 'S' to indicate to host that this is a serial programmer cpi R16,'p' Return programmer type brne L38 ldi R16,'S'

; else if (R16=='p')

; uartSend('S')

Serial rjmp L70 ; uartSend(R16) and go up for next command ;--------------------- Command 'R' is "Read one word from program memory" -------------; reads one word from the 'current' address that is stored in R26 and increments R26 L38: cpi R16,'R' ; else if(R16=='R') Read program memory brne L40 movw ZL,R26 address of memory to be read lpm memory LSB; lpm memory MSB;

R24,Z+ store LSB in R24 and Z pointer ++ R16,Z+ store MSB in R16 and Z pointer ++

rcall uartSend back MSB to host

; load Z-pointer with

; read program ; read program

; uartSend(R16) write

movw R26,ZL 'current' address += 2 mov R16,R24 rjmp L70 uartSend(R16) write back the LSB to host and go

; increment the

; LSB stored in R16 ; ; up for next command

;--------------------- Command 'D' is "write data to -------------L40: cpi R16,'D' Write data to EEPROM brne L41 rcall uartGet write from the UART out EEDR,R16 ldi R17,6 rcall EepromTalk rjmp L68 uartSend('\r') Confirm the command to host with CR

EEPROM" --------------

; else if (R16=='D')

; fetch the data to ; EEDR = uartGet() ; write EEPROM ;

;--------- Command 'b' is question from host for block mode capability--------------; simple anser is 'N' 'N', no bootloader does not support blockmode L41: cpi R16, 'b' Blockmode? brne L42 ldi R16,'N' rcall uartSend

; if(R16=='b') 'b' =

; send 'N'

ldi R16,'N' ; send 'N' rjmp L70 ; uartSend(R16) Send the 'N' and go up for next command ;--------------------- Command 'd' is "read data from EEPROM ---------------------------L42: cpi R16,'d' ; else if (R16=='d') Read data from EEPROM brne L43 ldi R17,1 ; read EEPROM rcall EepromTalk ; R16 = EEPROM data rjmp L70 ; uartSend(R16)

;-------------------------- Command ':' is universal command --------------------------; Host sends 3 more bytes which must be used to determine the required action. AVRProg ; uses the ':' with parameters to do things that could simply be done by r/F/N. ; We have to map recognized parameters to the refering action.

L43: cpi R16,':' Universal Command brne L44

; else if(R16==':')

;.............. read in the parameters ............................... rcall uartGet mov uni_cmd1, r16

; R16 = uartGet() ; store the read byte

rcall uartGet mov uni_cmd2, r16

; R16 = uartGet() ; store the read byte

rcall uartGet mov uni_cmd3, r16

; R16 = uartGet() ; store the read byte

;.................................................................. ... clr r16 with zero, if parameters are not

; preset r16 ;

recognized, zero will be returned to host ;.................................................................. ... cpi uni_cmd1, 0x58 paramter is 0x58 brne cmd1_not_0x58

; check if 1st

cpi uni_cmd2, 0x00 paramter is 0x00 brne cmd2_not_0x00_1

; check if 2nd

; -> 58 00 is read lock bits, ldi ZL,1 0001 (-> readFuseAndLock will read lock) rcall readFuseAndLock

; Z pointer = ; go get the requested bits

cmd2_not_0x00_1: cpi uni_cmd2, 0x08 paramter is 0x08 brne cmd2_not_0x08

; check if 2nd

; -> 58 08 is read fuse high bits, ldi ZL,3 ; Z pointer = 0003 (-> readFuseAndLock will read high fuse) rcall readFuseAndLock ; go get the requested bits cmd2_not_0x08: cmd1_not_0x58: cpi uni_cmd1, 0x50 paramter is 0x50 brne cmd1_not_0x50

; check if 1st

cpi uni_cmd2, 0x00 paramter is 0x00 brne cmd2_not_0x00_2 ; -> 50 00 is read fuse bits, clr ZL 0000 (-> readFuseAndLock will read fuse) rcall readFuseAndLock

; check if 2nd

; Z-pointer = ; go get the requested bits

cmd2_not_0x00_2: cmd1_not_0x50: rcall uartSend the read lock/fuse bits rjmp L68 uartSend('\r') and go up for next command

; uartSend(bits) send

;

;--------------------- Command 'F' is "read fuse bits" --------------------------------L44: cpi R16,'F' ; else if(R16=='F') Read fuse bits brne L46 clr ZL ; Z-pointer = 0000 (-> readFuseAndLock will read fuse) rjmp L50 ; rcall readFuseAndLock

;--------------------- Command 'r' is "read lock bits" --------------------------------L46: cpi R16,'r' ; else if(R16=='r') Read lock bits brne L48 ldi ZL,1 ; Z pointer = 0001 (-> readFuseAndLock will read lock) rjmp L50 ; rcall readFuseAndLock

;--------------------- Command 'N' is "read fuse high bits" ---------------------------L48: cpi R16,'N' ; else if(R16=='N') Read high fuse bits brne L52 ldi ZL,3 ; Z-pointer = 0003 (-> readFuseAndLock will read high fuse)

;-------- for all previous commands F,r,N hear we call the readFuseAndLock -------------; function that will read the bits that are indicated by the Z-register L50:

rcall readFuseAndLock rjmp L70 uartSend(R16)

;

;--------------------- Command 't' is Return supported devices code -------------------; obviously we return only the device code of the mega8 here L52: cpi R16,'t' ; else if(R16=='t') Return supported devices code brne L54 ldi R16,DT rcall uartSend Device Type of Mega8 clr R16 of AVRProg requires the termination of

; Device Type ; uartSend(DT) send

; command set ; the

t-command with a \0 not with a CR as other commands rjmp L70 and go up for next command

; uartSend(0)

; ---------------- ignored commands that are not sensible for boot loader -------------; The following 4 commands only make sense for a general programmer, not for a bootloader. ; As theres commands come with an additional byte as parameter, with have to fetch that ; byte from the UART to avoid messing up the UART reading. L54: cpi R16,'l' Loader lockbits breq L56

; 'l' = Write Boot

cpi R16,'x' breq L56

; 'x' = Set LED

cpi R16,'y' breq L56

; 'y' = Clear LED

cpi R16,'T'

; 'T' = Select device

type brne L60 L56: rcall uartGet rjmp L68 uartSend('\r') and go up for next command

; R16 = uartGet() ;

;--------------------- Command 'S' is Return software identifier ----------------------L60: cpi R16,'S' ; else if(R16=='S') Return software identifier brne L62

ldi ZL,low(2*Soft_Id) Z-Register ldi ZH,high(2*Soft_Id)

; load address of String into

L61: lpm R16,Z+ character of the string and increment string pointer tst R16 breq L72 character output loop charcter was '\0' rcall uartSend character via the UART rjmp L61 of loop for next character

; read one

; exit the

; send the read

; go to start

;--------------------- Command 'V' is Return software Version -------------------------L62: cpi R16,'V' ; else if (R16=='V') Return Software Version brne L63 ldi R16, VER_H software version higher number rcall uartSend

; send bootloader

ldi R16, VER_L software version lower number rjmp L70 go up for next command

; send bootloader ; uartSend and

;--------------------- Command 'v' is Return hardware Version -------------------------L63: cpi R16,'v' ; else if (R16=='v') Return hardware Version brne L64 ldi R16, VERH_H software version higher number rcall uartSend

; send bootloader

ldi R16, VERH_L software version lower number rjmp L70 go up for next command

; send bootloader ; uartSend and

;--------------------- Command 's' is Return Signature Byte ---------------------------L64: cpi R16,'s' ; else if (R16=='s') Return Signature Byte brne L65 ldi R16,SB1 Signature Byte 1

; uartSend(SB1)

rcall uartSend ldi R16,SB2 Signature Byte 2 rcall uartSend

; uartSend(SB2)

ldi R16,SB3 Signature Byte 3 rjmp L70 go up for next command

; uartSend(SB3) ; uartSend and

;--------------------- Command '.' is new universal command ---------------------------; this command will be ignored, only the inteface will be handled correctly L65: cpi R16,'.' ; else if (R16=='.') New Universal Command brne L66 ;.............. read in the 4 parameters ............................... rcall rcall rcall rcall

uartGet uartGet uartGet uartGet

; ; ; ;

R16 R16 R16 R16

= = = =

uartGet() uartGet() uartGet() uartGet()

; ...................................................................... clr R16 rcall uartSend rjmp L68 uartSend('\r') and go up for next command

; uartSend(/0)

;

;++++++++++++++ handling the different command till here ++++++++++++++++++++++++++++++++ ; only general completion for all commands below

;---------------------- failed commands can end up here -------------------------------; an '?' is send via the UART to indicate fail host, then main loop starts again L66: ldi R16,'?' rjmp L70 uartSend(R16)

; else uartSend('?') ;

;--------- successfully completed commands without return value can end up here --------; an CR is sent via the UART to confirm execution to host, then main loop starts again L68: ldi R16,13 uartSend('\r')

;

;------------ successfully completed commands with return value can end up here --------; the return value is sent via the UART to confirm execution to host ; then main loop starts again L70: rcall uartSend ; uartSend(R16) L72: rjmp L10 beginning of main loop

; jump up to

;-------------------------- end of main loop -------------------------------------------

;================= end of main program, only subroutines from here on ===================

;------------------ reads fuse or lock bits (depending on Z-Reg.) -----------readFuseAndLock: ; An LPM instruction within three cycles after BLBSET and SPMEN are set in the SPMCR ; Register, will read either the Lock bits or the Fuse bits ; (depending on Z0 in the Z pointer) into the destination register. rcall wait_for_spm ready to accept a new task clr ZH high byte = 0

; make sure SPM is

; Z pointer

ldi R24,(1<
L90: sbic EECR,EEWE

; wait until EEWE ==

rjmp L90 in R16,EEDR

; R16 = EEDR

0

ret ;---------------- send one character via UART (parameter is r16) ------------uartSend: sbis UCSRA,UDRE ; wait for empty transmit buffer (until UDRE==1) rjmp uartSend out UDR,R16 ; UDR = R16, start transmission ret ;---------------- read one character from UART (returned in r16) ------------uartGet: sbis UCSRA,RXC data (until RXC==1) rjmp uartGet in R16,UDR received data in R16

; wait for incoming

; return

ret ;-------------------- wait for SPM to be ready for new tasks ----------------; while( SPMCR_REG & (1<
; read the content of ; check if bit SPMEN is set ; and do more loops

; check that no

ret

; ---------------------------- re-enable the RWW section --------------------; When programming (page erase or page write) to the RWW section, the RWW section ; is blocked for reading (the RWWSB will be set by hardware). To re-enable the RWW ; section, the user software must wait until the programming is completed (SPMEN will be ; cleared). Then, if the RWWSRE bit is written to one at the same time as SPMEN, the ; next SPM instruction within four clock cycles re-enables the RWW section.

; If this is not done, all addresses will read $FF even if they contain other values. enable_rww: rcall wait_for_spm ready to accept a new task

; make sure SPM is

ldi r16, (1<
; set rwwsre and spmen in

spm initiate the reenabling

; for

;

ret pause200: ldi pa_10ms, 20 ;---------------------------------- Pause -----------------------------------; Delays the CPU the selected periode, parameter pa_10ms is in 10ms steps pause: ldi tmp_r, TmrLoad

; preset the counter for 100 Hz

out TCNT0, tmp_r

; cycles till overflow

(10ms)

in tmp_r, TIFR sbr tmp_r, (1<
; reset the overflow flag

pw: ;LR**************************** sbic UCSRA,RXC ; check for incoming data (if RXC==1) rjmp PauseEnd ;LR**************************** in tmp_r, TIFR ; check if overflow flag is set sbrs tmp_r, TOV0 rjmp pw ; if not, wait more ;--- do this 10ms as often as requested in parameter pa_10ms dec pa_10ms ; decrement the counter brne pause ; and do the loop again if not zero yet PauseEnd:

ret

;---------------- data for identifier string --------------------------------Soft_Id: .DB "AVRB_M8", 0

:020000020000FC :101E0000F8940FE50DBF04E00EBF22243324909A0E :101E1000919A899A41E050EA06E0F101EF01F1015F :101E2000019700408099E1F781F12197349668F19C

:101E3000809BFBCF0F2EC5950694E9F72397269636 :101E400068F7EA35F20550F3F797F695E7952F0115 :101E5000CAE0E6EBFFE10590002031F078D00016F3 :101E6000D1F3CA9591F0F5CF06EA8AD070D0E1F7A8 :101E70000AEA86D06CD0F1F76AD0F1F3F101E89468 :101E80000430F0F059F1063018F422BA21BAB8C083 :101E900031F45DD05CD0672859F331010FC00730B1 :101EA00059F455D019F453D0005821F00590001280 :101EB0006894F7CF1EF0DCCF07EADBCF0BEAD9CF6F :101EC000ECEBFFE1C0E0EC0FF21DC4910150D8F73C :101ED00008EA56D00591C150E0F7CACFA0E6B0E0BD :101EE000ED0135D021F433D00058689431F0E894F6 :101EF0000D93A03204E0B007A1F7AC17BD0731F194 :101F0000A0E2B4E0E054FC4F10E232971E900E9035 :101F100001E015D01A95C9F7E0301EE1F107A8F4E9 :101F200003E00DD005E009D0AC17BD0769F776F0E6 :101F3000E054FC4F09EA24D0D4CF01D001E107BF1F :101F4000E89507B700FDFDCF0895B8CF91CF809BEE :101F5000FECF8099FECF18E0C2019695879523D0D9 :101F600021D006958099006807FD642676946794D1 :101F700008F4642608F475261A9591F7053A089531 :101F800011D09198149119E0009500C000C00AD0BA :101F9000069518F40000919802C0919A00C01A9515 :101FA000A1F70895C2010497F0F78D3F18F011F0E2 :101FB0008F3F01F00895506564610000030107033D :0A1FC00003C0041E930704001E0076 :00000001FF