logo elektroda
logo elektroda
X
logo elektroda
REKLAMA
REKLAMA
Adblock/uBlockOrigin/AdGuard mogą powodować znikanie niektórych postów z powodu nowej reguły.

BASCOM - Boodloader z karty MMC

TomekMus 29 Cze 2009 00:50 2978 4
REKLAMA
  • #1 6716413
    TomekMus
    Poziom 17  
    Chcę zrobić taki booloadre który będzie działał następująco.
    1. Wysyłam po RS'ie do uC pamięć FLASH następnie uC kopiuje na kartę MMC (od adresu 1 do ... n) - gdzie te adresy są przypisane na stałe w programie uC

    2. Następnie uC otrzymuje informacje-rozkaz że na karcie MMC ma FLASH do aktualizacji

    3. Boodloeadr aktualizuje FLASH z MMC


    Poniżej zamieściłem boodloader z standardowej biblioteki Bascoma, jak go przerobić na taki by aktualizował FLASH z MMC a nie z RS'a.

    Jak napiszę regółkę co wyśle FLASH na katrte MMC, tylko jak uC dostanie rozkaz to ma uruchomić aktualizacje.


    
    '-------------------------------------------------------------------------------
    
    'IMPORTANT : Look at BOOTLOADER.BAS which is simpler
    
    '-------------------------------------------------------------------------------
    'name                     : boot128.bas
    'copyright                : (c) 1995-2005, MCS Electronics
    'purpose                  : bootloader example for the M128 in M128 mode
    'micro                    : Mega128
    'suited for demo          : yes
    'commercial addon needed  : no
    'use in simulator         : not possible
    '
    'set fusebit KL and M to '1'
    'At start up a message is displayed. When you make PIND.7 low the
    'bootloader will be started
    'This program serves as an example. It can be changed for other chips.
    'Especially the page size and the boot entry location might need a change
    '-------------------------------------------------------------------------------
    
    'Our communication settings
    $crystal = 4000000
    $baud = 19200
    $regfile = "m128def.dat"
    $hwstack = 32                                               ' default use 32 for the hardware stack
    $swstack = 10                                               'default use 10 for the SW stack
    $framesize = 40                                             'default use 40 for the frame space
    
    Print "Checking bootloader"
    Portd.7 = 1
    If Pind.7 = 0 Then
       Print "Entering bootloader"
       jmp $fe00                                                ' make a jump to the boot code location. See the datasheet for the entrypoint
    End If
    Print "Not entering bootloader"
    
    'you code would continue here
    End
    
    
    
    
    '!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    '                    B O O T  L O A D E R
    '!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    'The $boot diretive will bind the code below into address specified
    'This will generate large files with FFFF opcode from the end of the normal program to the start
    'of the bootcode
    'Note that the bootloader is written in ASM. This because the bootloader may not call routines from
    'the main program. Why? Because during programming they get erased!
    $boot = $fe00
    
    'no interrupts are allowed during bootloader programming
    Disable Interrupts
    
    
    'Standard Intel hex file can be sent
    ':10 0000 00 0C 94 2400189500001895000018950000 25
    ':00 0000 01 FF
    ' size , address,record type, data, checksum
    'This sample bootloader checks for the checksum and displays ! so you know something wend wrong
    
    'The same baudrate is used as the main program is using
    'but we can change it here when we like. Just unremark the next line and/or change it
    'But take in mind that the bootloader sender must use the same baud rate !!!
    'Baud = 19200
    
    
    clr r18                                          ; word counter for written data
    clr r22                                          ; page counter LSB
    clr r23                                          ; page counter MSB
    
    rcall _erase_page
    
    
    
    _read_lines:
      rcall _rec_line                                ; get line into SRAM pointed by X
      ldi r26,$01                                    ; point to start of line
      ldi r27,$01
      ld r24,x+                                      ; get char in r24
      rcall _hex2number                              ; convert result in r17
      ld r24,x+
      rcall _hex2number2                             ; convert second char , r17 holds the number of hex pairs to get
      mov r19,r17                                    ; number of entries
    ! sub r16,r17                                    ; checksum
      tst r19
      brne _readnext                                 ; not the end record
      rjmp _write_last_page                          ; final line so write the last page
    
    _readnext:
     ldi r25,3
    _docheck:
     ld r24,x+                                      ; get char in r24
     rcall _hex2number                              ; convert result in r17
     ld r24,x+
     rcall _hex2number2                             ; convert second char , r17 holds the data
     !sub r16,r17
     dec r25
     brne _docheck
    
    '  adiw xl,6                                      ; point to first pair
    _readnextpair:
      ld r24,x+                                      ; get char in r24
      rcall _hex2number                              ; convert result in r17
      ld r24,x+
      rcall _hex2number2                             ; convert second char , r17 holds the data
      mov r0,r17                                     ; save in r0
    ! sub r16,r17                                    ; checksum
      dec r19                                        ; adjust pair data counter
      ld r24,x+                                      ; get char in r24
      rcall _hex2number                              ; convert result in r17
      ld r24,x+
      rcall _hex2number2                             ; convert second char , r17 holds the data
      mov r1,r17                                     ; save data
    ! sub r16,r17                                    ; checksum
      rcall _write_page                              ; write into page buffer
      cpi r18,128                                     ; page is 256 bytes is 128 words
      breq _writeit                                  ; write page since it is full
    _lbl1:
      dec r19                                        ; adjust data pair
      brne _readnextpair                             ; more data
    ' ----------------checksum checkining ---------------
      ld r24,x+                                      ; get char in r24
      rcall _hex2number                              ; convert result in r17
      ld r24,x+
      rcall _hex2number2                             ; convert second char , r17 holds the data
      cp r16,r17                                     ; checksum ok?
      breq _checkok                                  ; yes
    _lbl2:
      sbis usr,5
      rjmp _lbl2
      ldi r24, asc("!")                              ; load !
      !out udr,r24                                   ; show ! so we know there is an error
    ' note that you only get an indication something wend wrong,there is no error recovery !!!
    
    _checkok:
      rjmp _read_lines                               ; next line
    
    _writeit:
      rcall _save_page                               ; save page
      rcall _erase_page                              ; erase next page
      Rjmp _lbl1                                     ; continue
    
    _write_last_page:
      rcall _save_page                               ; save last page
    _exit_page:
      jmp $0000                                      ; exit needs a reset
    
    
    
    ' get 1 byte from serial port and store in R24
    _recbyte:
      Sbis USR, 7                                    ; Wait for character
      rjmp _recbyte
      in r24, UDR                                    ; get byte
    Ret
    
    'get one line from the serial port and store in location pointed by X
    _rec_line:
      ldi r26,$00                                    ; point to first location in SRAM
      ldi r27,$01
      clr r16
    _rec_line5:
      sbis usr,5
      rjmp _rec_line5
      ldi r24, 63 ; ?
      !out udr,r24                                   ; show ? so we know we can send next line
    _rec_line1:
      rcall _recbyte                                 ; get byte
      cpi r24,13                                     ; enter?
      breq _rec_line2                                ; yes ready
      st x+,r24                                      ; no so store in sram buffer
      rjmp _rec_line1                                ; next byte
    _rec_line2:
      clr r24                                        ; string terminator
      st x,r24
    ret
    
    ' convert HEX byte in r24 into bin value , on exit byte in r17
    _hex2number:
      clr r17
    _hex2number4:
      Subi R24,65                                    ; subtract 65
      Brcc _hex2number3                              ; in case carry was cleared
      Subi R24,249                                   ; not
    _hex2number3:
      Subi R24,246
      Add R17,R24                                    ; add to accu
    ret
    
    ';called for the second byte
    _hex2number2:
      Lsl R17                                        ; shift data
      Lsl R17
      Lsl R17
      Lsl R17
      rjmp _hex2number4                              ; handle the conversion
    
    
    
    _enable_page:
     rcall _wait_spm
     ldi r24,17                                      ; reenable page
     sts  Spmcr , R24
     spm
     nop
     nop
    rjmp _wait_spm
    
    
    
    'page address in z7-z13
    _erase_page:
      rcall _wait_spm
      mov r31,r22                                    ; page address z8-z15
    ! out rampz,r23                                  ; bit 9 of pageaddress goes into Z16
      clr r30
      ldi r24,3                                      ; page erase command
      sts  Spmcr , R24
      spm
      nop
      nop
      rcall _wait_spm
      rcall _enable_page
    ret
    
    _write_page:
      rcall _wait_spm
      mov r31,r22                                    ; page address z8-z15
    ! out rampz,r23                                  ; bit 9 of page address goes into Z16(bit 0 of rampz)
      mov r30,r18                                    ; word address buffer counter
      lsl r30
      ldi r24,1                                      ; buffer fill
      sts  Spmcr, R24
      spm
      nop
      nop
      rcall _wait_spm
      inc r18  ; next word address
    ret
    
    
    _save_page:
    'z0-z6 must be 0
    'z7-z13 is the page address
    'r0 and r1 are ignored
      rcall _wait_spm
      mov r31,r22                                     ; LSB of page counter
    ! out rampz,r23                                   ; bit nine goes into bit 0 of rampz
      clr r30
      ldi r24,5                                       ; write page
      sts  Spmcr , R24
      spm
      nop
      nop
      rcall _wait_spm
    
      rcall _enable_page
      clr r18                                         ; page word address counter
      subi r22,-1                                     ; increment page counter
      sbci r23,255
    ret
    
    _wait_spm:
       LDS R25,SPMCR
       SBRC R25,0
       RJMP _WAIT_SPM                                 ; Wait for SPMEN flag cleared
    RET
    
    End
    
    'Note that this is just an example. A better usage of the bootloader is to
    'set the reset vector to the bootloader.
    'The bootloader then can check at reset, if it must program the chip
    'When the chip does not need to be programmed, it can jump to the normal reset vector(0)
    'You can test for a few magic bytes sendt by the loader to see if the chip must be programmed. This way you do
    'not need the additional pin/switch.
    'you can send the data in binary form too to speed up things. This way you can also handle errors
    '
    
  • REKLAMA
  • Pomocny post
    #2 6716644
    maciej38
    Poziom 11  
    Zobacz to gotowy bootloader z karty SD/MMC/CF (pliki dostępne po zalogowaniu)
    Link

    Bootloader sprawdza nazwę pliku i/lub stan określonego PINu i programuje procek plikiem z karty.
    Wcześniej wystarczy tylko umieścić taki plik na karcie.
  • REKLAMA
  • #3 6720038
    TomekMus
    Poziom 17  
    Nie moge tego znalesc
  • REKLAMA
  • Pomocny post
    #4 6720740
    maciej38
    Poziom 11  
    Wszystko jest pod podanym wyżej linkiem.
    Trzba się tylko zalogować

    Forum AVR-DOS, wątek Update Program from Card
    drugi post od góry ma załącznik z plikami.

    Pozdrawiam
  • #5 6743694
    TomekMus
    Poziom 17  
    Dzięki, udało się ściągnąć po zalogowaniu.
REKLAMA