• AVR Freaks

Hot!PIC32MM bootloader process explanation

Author
stoyanoff
Super Member
  • Total Posts : 252
  • Reward points : 0
  • Joined: 2011/01/10 03:37:28
  • Location: 0
  • Status: offline
2019/12/03 00:01:40 (permalink)
0

PIC32MM bootloader process explanation

Hi, Everyone! I`m making my own bootloader system. I want to use extenal flash to load the new program runtime, reset the controller and load it to the uC flash. So there are multiple things I don`t fully understand.
First: About the .hex file. Can you tell me where I can find info about the structure of the HEX file? I suppose every row starts with ':', address and info. But this is just a suggestion. I think I should remove the rows which are going to affect my bootloader section, so I need a way to determine which are they.
Second: I`m looking at EN1388 framework.c file. There a special interface is used to transfer the hex file to the controller. I don`t need that. I can do it run time. But I need to know if there are sections into the hex file row containing CRC, different type of records and so on. Or it is just pure address + data?! 
Thanks!
 
#1

12 Replies Related Threads

    stoyanoff
    Super Member
    • Total Posts : 252
    • Reward points : 0
    • Joined: 2011/01/10 03:37:28
    • Location: 0
    • Status: offline
    Re: PIC32MM bootloader process explanation 2019/12/03 05:55:17 (permalink)
    0
    Ok! I found info! How can I remove from the .HEX file rows connected to the bootloader? To delete the rows with addresses in the bootloader address space? I don`t want the new program vertion to update the bootloader section!
    Thanks!
    #2
    Jim Nickerson
    User 452
    • Total Posts : 6797
    • Reward points : 0
    • Joined: 2003/11/07 12:35:10
    • Location: San Diego, CA
    • Status: online
    Re: PIC32MM bootloader process explanation 2019/12/03 06:53:13 (permalink)
    0
    In my system the bootloader skips over the hex rows that would cause a problem.
    #3
    NKurzman
    A Guy on the Net
    • Total Posts : 19039
    • Reward points : 0
    • Joined: 2008/01/16 19:33:48
    • Location: 0
    • Status: offline
    Re: PIC32MM bootloader process explanation 2019/12/03 07:50:51 (permalink)
    5 (1)
    I do the same thing. My bootloaders Will not overwrite themselves.
    post edited by NKurzman - 2019/12/03 08:12:52
    #4
    stoyanoff
    Super Member
    • Total Posts : 252
    • Reward points : 0
    • Joined: 2011/01/10 03:37:28
    • Location: 0
    • Status: offline
    Re: PIC32MM bootloader process explanation 2019/12/04 04:22:23 (permalink)
    0
    Ok! A simple question, just to be sure. I am writing my functions for decoding Extended Segment Address(02) and Extended Linear Address (04). So in case of 02 package the ext_seg_addr should take the 2 bites from the package is put them is between -
    0102 - package bites
    ext_seg_addr=0x00010200
    and in case of 04 should put them like that- >
    0102 - package bites
    ext_lin_addr=0x01020000
    Is that correct?
    I`ve noticed the memcpy funct writes the databites from the liest significant->
    data->01020304
    memcpy(&dataholder,&data,4);
    ->result dataholder->04030201
    Is that correct?
    post edited by stoyanoff - 2019/12/04 07:21:38
    #5
    Jim Nickerson
    User 452
    • Total Posts : 6797
    • Reward points : 0
    • Joined: 2003/11/07 12:35:10
    • Location: San Diego, CA
    • Status: online
    Re: PIC32MM bootloader process explanation 2019/12/04 07:26:08 (permalink)
    0
    I used form AN1388  the source code to decode the hex line.
    #6
    stoyanoff
    Super Member
    • Total Posts : 252
    • Reward points : 0
    • Joined: 2011/01/10 03:37:28
    • Location: 0
    • Status: offline
    Re: PIC32MM bootloader process explanation 2019/12/09 04:31:07 (permalink)
    0
    Hi! So I`ve written my bootloader and now I have to modify the ld file. So I`m folloing the instructions int the AN1388, but I don`t know how to determine how big should be the bootloader area. The document says I have to put the main program in a different area so the bootloader can erase only it. Where should I check how big is my bootloader?
    Thanks!
    #7
    Jim Nickerson
    User 452
    • Total Posts : 6797
    • Reward points : 0
    • Joined: 2003/11/07 12:35:10
    • Location: San Diego, CA
    • Status: online
    Re: PIC32MM bootloader process explanation 2019/12/09 07:46:10 (permalink)
    0
    When I compile my bootloader I tick the Display Memory Usage box

     

    Attached Image(s)

    #8
    stoyanoff
    Super Member
    • Total Posts : 252
    • Reward points : 0
    • Joined: 2011/01/10 03:37:28
    • Location: 0
    • Status: offline
    Re: PIC32MM bootloader process explanation 2019/12/09 08:22:12 (permalink)
    0
    Just a second! Stupid question again! As far as I understand I have to compile the project twice - first only the bootloader(to see the memory usage) and then I add the rest?
    Thanks!
    PP: I haven`t done this before and I`m a little bit confused!
    #9
    hudejun
    Electrical engineer
    • Total Posts : 15
    • Reward points : 0
    • Joined: 2019/12/05 08:48:06
    • Location: 0
    • Status: offline
    Re: PIC32MM bootloader process explanation 2019/12/09 08:56:43 (permalink)
    #10
    stoyanoff
    Super Member
    • Total Posts : 252
    • Reward points : 0
    • Joined: 2011/01/10 03:37:28
    • Location: 0
    • Status: offline
    Re: PIC32MM bootloader process explanation 2019/12/13 01:22:42 (permalink)
    0
    Ok! Now I have my bootloader. So I have to modify my *.ld file. I`m reading APPENDIX C of AN1388. So the example there looks like this:

     
    MEMORY{
    exception_mem : ORIGIN = 0x9D000000, LENGTH = 0x1000
    kseg0_boot_mem : ORIGIN = (0x9D000000 + 0x1000), LENGTH = 0x970
    kseg1_boot_mem : ORIGIN = (0x9D000000 + 0x1000 + 0x970), LENGTH = 0x490
    kseg0_program_mem (rx):ORIGIN = (0x9D000000 + 0x1000 + 0x970 + 0x490), LENGTH = (0x80000 - (0x1000 + 0x970 + 0x490))
    debug_exec_mem : ORIGIN = 0xBFC02000, LENGTH = 0xFF0
    config3 : ORIGIN = 0xBFC02FF0, LENGTH = 0x4
    config2 : ORIGIN = 0xBFC02FF4, LENGTH = 0x4
    config1 : ORIGIN = 0xBFC02FF8, LENGTH = 0x4
    config0 : ORIGIN = 0xBFC02FFC, LENGTH = 0x4
    kseg1_data_mem (w!x) : ORIGIN = 0xA0000000, LENGTH = 0x20000
    sfrs : ORIGIN = 0xBF800000, LENGTH = 0x100000
    configsfrs : ORIGIN = 0xBFC02FF0, LENGTH = 0x10
    }
     

    My controller is PIC32MM0256GPM048 and my *.ld script looks like this:

     
    MEMORY
    {
    kseg0_program_mem (rx) : ORIGIN = 0x9D000000, LENGTH = 0x40000
    debug_exec_mem : ORIGIN = 0x9FC00490, LENGTH = 0x760
    kseg0_boot_mem : ORIGIN = 0x9FC00490, LENGTH = 0x0
    kseg1_boot_mem : ORIGIN = 0xBFC00000, LENGTH = 0x490
    config_BFC01744 : ORIGIN = 0xBFC01744, LENGTH = 0x4
    config_BFC01748 : ORIGIN = 0xBFC01748, LENGTH = 0x4
    config_BFC0174C : ORIGIN = 0xBFC0174C, LENGTH = 0x4
    config_BFC01750 : ORIGIN = 0xBFC01750, LENGTH = 0x4
    config_BFC01754 : ORIGIN = 0xBFC01754, LENGTH = 0x4
    config_BFC01758 : ORIGIN = 0xBFC01758, LENGTH = 0x4
    config_BFC01760 : ORIGIN = 0xBFC01760, LENGTH = 0x4
    config_BFC017C4 : ORIGIN = 0xBFC017C4, LENGTH = 0x4
    config_BFC017C8 : ORIGIN = 0xBFC017C8, LENGTH = 0x4
    config_BFC017CC : ORIGIN = 0xBFC017CC, LENGTH = 0x4
    config_BFC017D0 : ORIGIN = 0xBFC017D0, LENGTH = 0x4
    config_BFC017D4 : ORIGIN = 0xBFC017D4, LENGTH = 0x4
    config_BFC017D8 : ORIGIN = 0xBFC017D8, LENGTH = 0x4
    config_BFC017E0 : ORIGIN = 0xBFC017E0, LENGTH = 0x4
    kseg0_data_mem (w!x) : ORIGIN = 0x80000000, LENGTH = 0x8000
    sfrs : ORIGIN = 0xBF800000, LENGTH = 0x100000
    configsfrs_BFC01740 : ORIGIN = 0xBFC01740, LENGTH = 0x1C
    configsfrs_BFC017C0 : ORIGIN = 0xBFC017C0, LENGTH = 0x1C
    }
     

    As you can see there is no exception_mem(I can esealy add it). Second the boot mem organization is a little bit different. As the datasheet of PIC32MM says its boot mem is located on 0x1FC00000 and is up to 0x1FC016FF. But my original *.ld uses just 1168(0x490)  bites. Should I keep this value or I shuold use the max size?
    Third: In the example the kseg0_program_mem is not different from the boot area - form 0x1D000000 to 0x1D00FFFF. _RESET_ADDR, _BEV_EXCPT_ADDR, _DBG_EXCPT_ADDR are all in the range of kseg1_boot_mem by default. Should I change anything? Do I have to just set the correct app address in the bootloader(I can see it from the map file) so the bootloader doesn`t write to his files?
    Thanks!
     
     
    post edited by stoyanoff - 2019/12/13 01:24:02
    #11
    hudejun
    Electrical engineer
    • Total Posts : 15
    • Reward points : 0
    • Joined: 2019/12/05 08:48:06
    • Location: 0
    • Status: offline
    Re: PIC32MM bootloader process explanation 2019/12/13 04:05:48 (permalink)
    0
    You can set exception addresses in this way.
     
    .reset _RESET_ADDR :
      {
        KEEP(*(.reset))
        KEEP(*(.reset.startup))
      } > kseg1_boot_mem
      .bev_excpt _BEV_EXCPT_ADDR :
      {
        KEEP(*(.bev_handler))
      } > kseg1_boot_mem
      /* Debug exception vector */
      .dbg_excpt _DBG_EXCPT_ADDR (NOLOAD) :
      {
        . += (DEFINED (_DEBUGGER) ? 0x8 : 0x0);
      } > kseg1_boot_mem
      /* Space reserved for the debug executive */
      .dbg_code _DBG_CODE_ADDR (NOLOAD) :
      {
        . += (DEFINED (_DEBUGGER) ? _DBG_CODE_SIZE : 0x0);
      } > debug_exec_mem

      .app_excpt _GEN_EXCPT_ADDR :
      {
        KEEP(*(.gen_handler))
      } > exception_mem

      .vector_0 _ebase_address + 0x200 + ((_vector_spacing << 5) * 0) :
      {
         KEEP(*(.vector_0))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_0) <= (_vector_spacing << 5), "function at exception vector 0 too large")
      .vector_1 _ebase_address + 0x200 + ((_vector_spacing << 5) * 1) :
      {
         KEEP(*(.vector_1))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_1) <= (_vector_spacing << 5), "function at exception vector 1 too large")
      .vector_2 _ebase_address + 0x200 + ((_vector_spacing << 5) * 2) :
      {
         KEEP(*(.vector_2))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_2) <= (_vector_spacing << 5), "function at exception vector 2 too large")
      .vector_3 _ebase_address + 0x200 + ((_vector_spacing << 5) * 3) :
      {
         KEEP(*(.vector_3))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_3) <= (_vector_spacing << 5), "function at exception vector 3 too large")
      .vector_4 _ebase_address + 0x200 + ((_vector_spacing << 5) * 4) :
      {
         KEEP(*(.vector_4))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_4) <= (_vector_spacing << 5), "function at exception vector 4 too large")
      .vector_5 _ebase_address + 0x200 + ((_vector_spacing << 5) * 5) :
      {
         KEEP(*(.vector_5))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_5) <= (_vector_spacing << 5), "function at exception vector 5 too large")
      .vector_6 _ebase_address + 0x200 + ((_vector_spacing << 5) * 6) :
      {
         KEEP(*(.vector_6))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_6) <= (_vector_spacing << 5), "function at exception vector 6 too large")
      .vector_7 _ebase_address + 0x200 + ((_vector_spacing << 5) * 7) :
      {
         KEEP(*(.vector_7))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_7) <= (_vector_spacing << 5), "function at exception vector 7 too large")
      .vector_8 _ebase_address + 0x200 + ((_vector_spacing << 5) * 8) :
      {
         KEEP(*(.vector_8))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_8) <= (_vector_spacing << 5), "function at exception vector 8 too large")
      .vector_9 _ebase_address + 0x200 + ((_vector_spacing << 5) * 9) :
      {
         KEEP(*(.vector_9))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_9) <= (_vector_spacing << 5), "function at exception vector 9 too large")
      .vector_10 _ebase_address + 0x200 + ((_vector_spacing << 5) * 10) :
      {
         KEEP(*(.vector_10))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_10) <= (_vector_spacing << 5), "function at exception vector 10 too large")
      .vector_11 _ebase_address + 0x200 + ((_vector_spacing << 5) * 11) :
      {
         KEEP(*(.vector_11))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_11) <= (_vector_spacing << 5), "function at exception vector 11 too large")
      .vector_12 _ebase_address + 0x200 + ((_vector_spacing << 5) * 12) :
      {
         KEEP(*(.vector_12))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_12) <= (_vector_spacing << 5), "function at exception vector 12 too large")
      .vector_13 _ebase_address + 0x200 + ((_vector_spacing << 5) * 13) :
      {
         KEEP(*(.vector_13))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_13) <= (_vector_spacing << 5), "function at exception vector 13 too large")
      .vector_14 _ebase_address + 0x200 + ((_vector_spacing << 5) * 14) :
      {
         KEEP(*(.vector_14))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_14) <= (_vector_spacing << 5), "function at exception vector 14 too large")
      .vector_15 _ebase_address + 0x200 + ((_vector_spacing << 5) * 15) :
      {
         KEEP(*(.vector_15))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_15) <= (_vector_spacing << 5), "function at exception vector 15 too large")
      .vector_16 _ebase_address + 0x200 + ((_vector_spacing << 5) * 16) :
      {
         KEEP(*(.vector_16))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_16) <= (_vector_spacing << 5), "function at exception vector 16 too large")
      .vector_17 _ebase_address + 0x200 + ((_vector_spacing << 5) * 17) :
      {
         KEEP(*(.vector_17))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_17) <= (_vector_spacing << 5), "function at exception vector 17 too large")
      .vector_18 _ebase_address + 0x200 + ((_vector_spacing << 5) * 18) :
      {
         KEEP(*(.vector_18))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_18) <= (_vector_spacing << 5), "function at exception vector 18 too large")
      .vector_19 _ebase_address + 0x200 + ((_vector_spacing << 5) * 19) :
      {
         KEEP(*(.vector_19))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_19) <= (_vector_spacing << 5), "function at exception vector 19 too large")
      .vector_20 _ebase_address + 0x200 + ((_vector_spacing << 5) * 20) :
      {
         KEEP(*(.vector_20))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_20) <= (_vector_spacing << 5), "function at exception vector 20 too large")
      .vector_21 _ebase_address + 0x200 + ((_vector_spacing << 5) * 21) :
      {
         KEEP(*(.vector_21))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_21) <= (_vector_spacing << 5), "function at exception vector 21 too large")
      .vector_22 _ebase_address + 0x200 + ((_vector_spacing << 5) * 22) :
      {
         KEEP(*(.vector_22))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_22) <= (_vector_spacing << 5), "function at exception vector 22 too large")
      .vector_23 _ebase_address + 0x200 + ((_vector_spacing << 5) * 23) :
      {
         KEEP(*(.vector_23))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_23) <= (_vector_spacing << 5), "function at exception vector 23 too large")
      .vector_24 _ebase_address + 0x200 + ((_vector_spacing << 5) * 24) :
      {
         KEEP(*(.vector_24))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_24) <= (_vector_spacing << 5), "function at exception vector 24 too large")
      .vector_25 _ebase_address + 0x200 + ((_vector_spacing << 5) * 25) :
      {
         KEEP(*(.vector_25))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_25) <= (_vector_spacing << 5), "function at exception vector 25 too large")
      .vector_26 _ebase_address + 0x200 + ((_vector_spacing << 5) * 26) :
      {
         KEEP(*(.vector_26))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_26) <= (_vector_spacing << 5), "function at exception vector 26 too large")
      .vector_27 _ebase_address + 0x200 + ((_vector_spacing << 5) * 27) :
      {
         KEEP(*(.vector_27))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_27) <= (_vector_spacing << 5), "function at exception vector 27 too large")
      .vector_28 _ebase_address + 0x200 + ((_vector_spacing << 5) * 28) :
      {
         KEEP(*(.vector_28))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_28) <= (_vector_spacing << 5), "function at exception vector 28 too large")
      .vector_29 _ebase_address + 0x200 + ((_vector_spacing << 5) * 29) :
      {
         KEEP(*(.vector_29))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_29) <= (_vector_spacing << 5), "function at exception vector 29 too large")
      .vector_30 _ebase_address + 0x200 + ((_vector_spacing << 5) * 30) :
      {
         KEEP(*(.vector_30))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_30) <= (_vector_spacing << 5), "function at exception vector 30 too large")
      .vector_31 _ebase_address + 0x200 + ((_vector_spacing << 5) * 31) :
      {
         KEEP(*(.vector_31))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_31) <= (_vector_spacing << 5), "function at exception vector 31 too large")
      .vector_32 _ebase_address + 0x200 + ((_vector_spacing << 5) * 32) :
      {
         KEEP(*(.vector_32))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_32) <= (_vector_spacing << 5), "function at exception vector 32 too large")
      .vector_33 _ebase_address + 0x200 + ((_vector_spacing << 5) * 33) :
      {
         KEEP(*(.vector_33))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_33) <= (_vector_spacing << 5), "function at exception vector 33 too large")
      .vector_34 _ebase_address + 0x200 + ((_vector_spacing << 5) * 34) :
      {
         KEEP(*(.vector_34))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_34) <= (_vector_spacing << 5), "function at exception vector 34 too large")
      .vector_35 _ebase_address + 0x200 + ((_vector_spacing << 5) * 35) :
      {
         KEEP(*(.vector_35))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_35) <= (_vector_spacing << 5), "function at exception vector 35 too large")
      .vector_36 _ebase_address + 0x200 + ((_vector_spacing << 5) * 36) :
      {
         KEEP(*(.vector_36))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_36) <= (_vector_spacing << 5), "function at exception vector 36 too large")
      .vector_37 _ebase_address + 0x200 + ((_vector_spacing << 5) * 37) :
      {
         KEEP(*(.vector_37))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_37) <= (_vector_spacing << 5), "function at exception vector 37 too large")
      .vector_38 _ebase_address + 0x200 + ((_vector_spacing << 5) * 38) :
      {
         KEEP(*(.vector_38))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_38) <= (_vector_spacing << 5), "function at exception vector 38 too large")
      .vector_39 _ebase_address + 0x200 + ((_vector_spacing << 5) * 39) :
      {
         KEEP(*(.vector_39))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_39) <= (_vector_spacing << 5), "function at exception vector 39 too large")
      .vector_40 _ebase_address + 0x200 + ((_vector_spacing << 5) * 40) :
      {
         KEEP(*(.vector_40))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_40) <= (_vector_spacing << 5), "function at exception vector 40 too large")
      .vector_41 _ebase_address + 0x200 + ((_vector_spacing << 5) * 41) :
      {
         KEEP(*(.vector_41))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_41) <= (_vector_spacing << 5), "function at exception vector 41 too large")
      .vector_42 _ebase_address + 0x200 + ((_vector_spacing << 5) * 42) :
      {
         KEEP(*(.vector_42))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_42) <= (_vector_spacing << 5), "function at exception vector 42 too large")
      .vector_43 _ebase_address + 0x200 + ((_vector_spacing << 5) * 43) :
      {
         KEEP(*(.vector_43))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_43) <= (_vector_spacing << 5), "function at exception vector 43 too large")
      .vector_44 _ebase_address + 0x200 + ((_vector_spacing << 5) * 44) :
      {
         KEEP(*(.vector_44))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_44) <= (_vector_spacing << 5), "function at exception vector 44 too large")
      .vector_45 _ebase_address + 0x200 + ((_vector_spacing << 5) * 45) :
      {
         KEEP(*(.vector_45))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_45) <= (_vector_spacing << 5), "function at exception vector 45 too large")
      .vector_46 _ebase_address + 0x200 + ((_vector_spacing << 5) * 46) :
      {
         KEEP(*(.vector_46))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_46) <= (_vector_spacing << 5), "function at exception vector 46 too large")
      .vector_47 _ebase_address + 0x200 + ((_vector_spacing << 5) * 47) :
      {
         KEEP(*(.vector_47))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_47) <= (_vector_spacing << 5), "function at exception vector 47 too large")
      .vector_48 _ebase_address + 0x200 + ((_vector_spacing << 5) * 48) :
      {
         KEEP(*(.vector_48))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_48) <= (_vector_spacing << 5), "function at exception vector 48 too large")
      .vector_49 _ebase_address + 0x200 + ((_vector_spacing << 5) * 49) :
      {
         KEEP(*(.vector_49))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_49) <= (_vector_spacing << 5), "function at exception vector 49 too large")
      .vector_50 _ebase_address + 0x200 + ((_vector_spacing << 5) * 50) :
      {
         KEEP(*(.vector_50))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_50) <= (_vector_spacing << 5), "function at exception vector 50 too large")
      .vector_51 _ebase_address + 0x200 + ((_vector_spacing << 5) * 51) :
      {
         KEEP(*(.vector_51))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_51) <= (_vector_spacing << 5), "function at exception vector 51 too large")
      .vector_52 _ebase_address + 0x200 + ((_vector_spacing << 5) * 52) :
      {
         KEEP(*(.vector_52))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_52) <= (_vector_spacing << 5), "function at exception vector 52 too large")
      .vector_53 _ebase_address + 0x200 + ((_vector_spacing << 5) * 53) :
      {
         KEEP(*(.vector_53))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_53) <= (_vector_spacing << 5), "function at exception vector 53 too large")
      .vector_54 _ebase_address + 0x200 + ((_vector_spacing << 5) * 54) :
      {
         KEEP(*(.vector_54))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_54) <= (_vector_spacing << 5), "function at exception vector 54 too large")
      .vector_55 _ebase_address + 0x200 + ((_vector_spacing << 5) * 55) :
      {
         KEEP(*(.vector_55))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_55) <= (_vector_spacing << 5), "function at exception vector 55 too large")
      .vector_56 _ebase_address + 0x200 + ((_vector_spacing << 5) * 56) :
      {
         KEEP(*(.vector_56))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_56) <= (_vector_spacing << 5), "function at exception vector 56 too large")
      .vector_57 _ebase_address + 0x200 + ((_vector_spacing << 5) * 57) :
      {
         KEEP(*(.vector_57))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_57) <= (_vector_spacing << 5), "function at exception vector 57 too large")
      .vector_58 _ebase_address + 0x200 + ((_vector_spacing << 5) * 58) :
      {
         KEEP(*(.vector_58))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_58) <= (_vector_spacing << 5), "function at exception vector 58 too large")
      .vector_59 _ebase_address + 0x200 + ((_vector_spacing << 5) * 59) :
      {
         KEEP(*(.vector_59))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_59) <= (_vector_spacing << 5), "function at exception vector 59 too large")
      .vector_60 _ebase_address + 0x200 + ((_vector_spacing << 5) * 60) :
      {
         KEEP(*(.vector_60))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_60) <= (_vector_spacing << 5), "function at exception vector 60 too large")
      .vector_61 _ebase_address + 0x200 + ((_vector_spacing << 5) * 61) :
      {
         KEEP(*(.vector_61))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_61) <= (_vector_spacing << 5), "function at exception vector 61 too large")
      .vector_62 _ebase_address + 0x200 + ((_vector_spacing << 5) * 62) :
      {
         KEEP(*(.vector_62))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_62) <= (_vector_spacing << 5), "function at exception vector 62 too large")
      .vector_63 _ebase_address + 0x200 + ((_vector_spacing << 5) * 63) :
      {
         KEEP(*(.vector_63))
      } > exception_mem
      ASSERT (_vector_spacing == 0 || SIZEOF(.vector_63) <= (_vector_spacing << 5), "function at exception vector 63 too large")

    post edited by hudejun - 2019/12/13 04:07:14
    #12
    stoyanoff
    Super Member
    • Total Posts : 252
    • Reward points : 0
    • Joined: 2011/01/10 03:37:28
    • Location: 0
    • Status: offline
    Re: PIC32MM bootloader process explanation 2019/12/16 04:22:04 (permalink)
    0
    Hi, again! I`m watching a few examples from the harmony lib. So when I activate the "display memory option" I can see where all the functions are situated - mainly in kseg0_program_mem. But when I add a simple function to the project(my_function()) I can`t see it in this report! What should I do to enalbe this? I`ve tried to add the function in a sepated .c file and so on - no success. I don`t see any definitions in the project properties or I don`t know where to watch.
    Thanks!
    #13
    Jump to:
    © 2020 APG vNext Commercial Version 4.5