ورود به حساب ثبت نام جدید فراموشی کلمه عبور
برای ورود به حساب کاربری خود، نام کاربری و کلمه عبورتان را در زیر وارد کرده و روی «ورود به سایت» کلیک کنید.





اگر فرم ورود برای شما نمایش داده نمیشود، اینجا را کلیک کنید.









اگر فرم ثبت نام برای شما نمایش داده نمی‌شود، اینجا را کلیک کنید.









اگر فرم بازیابی کلمه عبور برای شما نمایش داده نمی‌شود، اینجا را کلیک کنید.





کاربران برچسب زده شده

نمایش نتایج: از 1 به 6 از 6
  1. #1
    2008/08/01
    26
    4

    تفاوت بوت لودرها

    سلام
    دوستان کسی می دونه با توجه به اینکه آردوینو های UNO و NANO و PRO MINI همگی دارای هسته مرکزی ATmega328 هستند .چرا بوت لودر ها متفاوت برای اونا نوشته شده؟
    به عبارت ساده تر وقتی با ریختن بوت لودر UNO با حجم 0.5 کیلو روی NANO می توان همان استفاده را از آن کرد چرا بوت لودر 2 کیلویی مستقل برای NANO نوشته شده؟
  2. #2
    2017/11/05
    Amol
    446
    158

    پاسخ : تفاوت بوت لودرها

    نقل قول نوشته اصلی توسط electron329

    مهمان عزیز شما حق دیدن لینک ها را ندارید

    عضویت

    سلام
    دوستان کسی می دونه با توجه به اینکه آردوینو های UNO و NANO و PRO MINI همگی دارای هسته مرکزی ATmega328 هستند .چرا بوت لودر ها متفاوت برای اونا نوشته شده؟
    به عبارت ساده تر وقتی با ریختن بوت لودر UNO با حجم 0.5 کیلو روی NANO می توان همان استفاده را از آن کرد چرا بوت لودر 2 کیلویی مستقل برای NANO نوشته شده؟
    برو تو فولدر بوت لودر ها بعد فایل boards.txt رو باز کن ببین چه فرق هایی داره






    امیرحسین ضیا
  3. #3
    2008/08/01
    26
    4

    پاسخ : تفاوت بوت لودرها

    نقل قول نوشته اصلی توسط azjaguar

    مهمان عزیز شما حق دیدن لینک ها را ندارید

    عضویت

    برو تو فولدر بوت لودر ها بعد فایل boards.txt رو باز کن ببین چه فرق هایی داره
    شما اگه رفتی می تونی یکی یا دوتا شو بگی؟
    برنامه ای شده تو یکی کار کنه تو اون یکی نه ؟
    وقتی بوت لودر 0.5 کیلویی UNO توی NANO همون کار رو می کنه چرا باید تو NANO بوت لودر 2کیلویی باشه.امتحان کنید.
    وقتی همشون برپایه ATmega328 کار می کنند.چه مزیتی توی بوت لودر 2 کیلویی درNANOوPRO MINI هست که در بوت لودر0.5 کیلویی UNO نیست؟
    ویرایش توسط electron329 : 2019/04/13 در ساعت 23:44
  4. #4
    2017/11/05
    Amol
    446
    158

    پاسخ : تفاوت بوت لودرها

    nano328.name=Arduino Nano w/ ATmega328


    nano328.upload.protocol=arduino
    nano328.upload.maximum_size=30720
    nano328.upload.speed=57600


    nano328.bootloader.low_fuses=0xFF
    nano328.bootloader.high_fuses=0xDA
    nano328.bootloader.extended_fuses=0x05
    nano328.bootloader.path=atmega
    nano328.bootloader.file=ATmegaBOOT_168_atmega328.h ex
    nano328.bootloader.unlock_bits=0x3F
    nano328.bootloader.lock_bits=0x0F


    nano328.build.mcu=atmega328p
    nano328.build.f_cpu=16000000L
    nano328.build.core=arduino
    nano328.build.variant=eightanaloginputs


    .
    .
    .
    atmega328.name=Arduino Duemilanove w/ ATmega328


    atmega328.upload.protocol=arduino
    atmega328.upload.maximum_size=30720
    atmega328.upload.speed=57600


    atmega328.bootloader.low_fuses=0xFF
    atmega328.bootloader.high_fuses=0xDA
    atmega328.bootloader.extended_fuses=0x05
    atmega328.bootloader.path=atmega
    atmega328.bootloader.file=ATmegaBOOT_168_atmega328 .hex
    atmega328.bootloader.unlock_bits=0x3F
    atmega328.bootloader.lock_bits=0x0F


    atmega328.build.mcu=atmega328p
    atmega328.build.f_cpu=16000000L
    atmega328.build.core=arduino
    atmega328.build.variant=standard
    .
    .
    .
    .
    .
    uno.name=Arduino Uno
    uno.upload.protocol=arduino
    uno.upload.maximum_size=32256
    uno.upload.speed=115200
    uno.bootloader.low_fuses=0xff
    uno.bootloader.high_fuses=0xde
    uno.bootloader.extended_fuses=0x05
    uno.bootloader.path=optiboot
    uno.bootloader.file=optiboot_atmega328.hex
    uno.bootloader.unlock_bits=0x3F
    uno.bootloader.lock_bits=0x0F
    uno.build.mcu=atmega328p
    uno.build.f_cpu=16000000L
    uno.build.core=arduino
    uno.build.variant=standard


    دلیل: ادغام دو پست برای جلوگیری از اسپم



    optiboot_atmega328.elf: file format elf32-avr


    Sections:
    Idx Name Size VMA LMA File off Algn
    0 .text 000001f4 00007e00 00007e00 00000054 2**1
    CONTENTS, ALLOC, LOAD, READONLY, CODE
    1 .version 00000002 00007ffe 00007ffe 00000248 2**0
    CONTENTS, READONLY
    2 .debug_aranges 00000028 00000000 00000000 0000024a 2**0
    CONTENTS, READONLY, DEBUGGING
    3 .debug_pubnames 0000005f 00000000 00000000 00000272 2**0
    CONTENTS, READONLY, DEBUGGING
    4 .debug_info 000002a8 00000000 00000000 000002d1 2**0
    CONTENTS, READONLY, DEBUGGING
    5 .debug_abbrev 00000178 00000000 00000000 00000579 2**0
    CONTENTS, READONLY, DEBUGGING
    6 .debug_line 00000488 00000000 00000000 000006f1 2**0
    CONTENTS, READONLY, DEBUGGING
    7 .debug_frame 00000080 00000000 00000000 00000b7c 2**2
    CONTENTS, READONLY, DEBUGGING
    8 .debug_str 0000014f 00000000 00000000 00000bfc 2**0
    CONTENTS, READONLY, DEBUGGING
    9 .debug_loc 000002d8 00000000 00000000 00000d4b 2**0
    CONTENTS, READONLY, DEBUGGING
    10 .debug_ranges 00000078 00000000 00000000 00001023 2**0
    CONTENTS, READONLY, DEBUGGING


    Disassembly of section .text:


    00007e00 <main>:
    #define rstVect (*(uint16_t*)(RAMSTART+SPM_PAGESIZE*2+4))
    #define wdtVect (*(uint16_t*)(RAMSTART+SPM_PAGESIZE*2+6))
    #endif


    /* main program starts here */
    int main(void) {
    7e00: 11 24 eor r1, r1
    #ifdef __AVR_ATmega8__
    SP=RAMEND; // This is done by hardware reset
    #endif


    // Adaboot no-wait mod
    ch = MCUSR;
    7e02: 84 b7 in r24, 0x34 ; 52
    MCUSR = 0;
    7e04: 14 be out 0x34, r1 ; 52
    if (!(ch & _BV(EXTRF))) appStart();
    7e06: 81 ff sbrs r24, 1
    7e08: f0 d0 rcall .+480 ; 0x7fea <appStart>


    #if LED_START_FLASHES > 0
    // Set up Timer 1 for timeout counter
    TCCR1B = _BV(CS12) | _BV(CS10); // div 1024
    7e0a: 85 e0 ldi r24, 0x05 ; 5
    7e0c: 80 93 81 00 sts 0x0081, r24
    UCSRA = _BV(U2X); //Double speed mode USART
    UCSRB = _BV(RXEN) | _BV(TXEN); // enable Rx & Tx
    UCSRC = _BV(URSEL) | _BV(UCSZ1) | _BV(UCSZ0); // config USART; 8N1
    UBRRL = (uint8_t)( (F_CPU + BAUD_RATE * 4L) / (BAUD_RATE * 8L) - 1 );
    #else
    UCSR0A = _BV(U2X0); //Double speed mode USART0
    7e10: 82 e0 ldi r24, 0x02 ; 2
    7e12: 80 93 c0 00 sts 0x00C0, r24
    UCSR0B = _BV(RXEN0) | _BV(TXEN0);
    7e16: 88 e1 ldi r24, 0x18 ; 24
    7e18: 80 93 c1 00 sts 0x00C1, r24
    UCSR0C = _BV(UCSZ00) | _BV(UCSZ01);
    7e1c: 86 e0 ldi r24, 0x06 ; 6
    7e1e: 80 93 c2 00 sts 0x00C2, r24
    UBRR0L = (uint8_t)( (F_CPU + BAUD_RATE * 4L) / (BAUD_RATE * 8L) - 1 );
    7e22: 80 e1 ldi r24, 0x10 ; 16
    7e24: 80 93 c4 00 sts 0x00C4, r24
    #endif
    #endif


    // Set up watchdog to trigger after 500ms
    watchdogConfig(WATCHDOG_1S);
    7e28: 8e e0 ldi r24, 0x0E ; 14
    7e2a: c9 d0 rcall .+402 ; 0x7fbe <watchdogConfig>


    /* Set LED pin as output */
    LED_DDR |= _BV(LED);
    7e2c: 25 9a sbi 0x04, 5 ; 4
    7e2e: 86 e0 ldi r24, 0x06 ; 6
    }


    #if LED_START_FLASHES > 0
    void flash_led(uint8_t count) {
    do {
    TCNT1 = -(F_CPU/(1024*16));
    7e30: 20 e3 ldi r18, 0x30 ; 48
    7e32: 3c ef ldi r19, 0xFC ; 252
    TIFR1 = _BV(TOV1);
    7e34: 91 e0 ldi r25, 0x01 ; 1
    }


    #if LED_START_FLASHES > 0
    void flash_led(uint8_t count) {
    do {
    TCNT1 = -(F_CPU/(1024*16));
    7e36: 30 93 85 00 sts 0x0085, r19
    7e3a: 20 93 84 00 sts 0x0084, r18
    TIFR1 = _BV(TOV1);
    7e3e: 96 bb out 0x16, r25 ; 22
    while(!(TIFR1 & _BV(TOV1)));
    7e40: b0 9b sbis 0x16, 0 ; 22
    7e42: fe cf rjmp .-4 ; 0x7e40 <main+0x40>
    #ifdef __AVR_ATmega8__
    LED_PORT ^= _BV(LED);
    #else
    LED_PIN |= _BV(LED);
    7e44: 1d 9a sbi 0x03, 5 ; 3
    }
    #endif


    // Watchdog functions. These are only safe with interrupts turned off.
    void watchdogReset() {
    __asm__ __volatile__ (
    7e46: a8 95 wdr
    LED_PORT ^= _BV(LED);
    #else
    LED_PIN |= _BV(LED);
    #endif
    watchdogReset();
    } while (--count);
    7e48: 81 50 subi r24, 0x01 ; 1
    7e4a: a9 f7 brne .-22 ; 0x7e36 <main+0x36>
    7e4c: cc 24 eor r12, r12
    7e4e: dd 24 eor r13, r13
    ch = SPM_PAGESIZE / 2;
    do {
    uint16_t a;
    a = *bufPtr++;
    a |= (*bufPtr++) << 8;
    __boot_page_fill_short((uint16_t)(void*)addrPtr,a);
    7e50: 88 24 eor r8, r8
    7e52: 83 94 inc r8
    addrPtr += 2;
    } while (--ch);


    // Write from programming buffer
    __boot_page_write_short((uint16_t)(void*)address);
    7e54: b5 e0 ldi r27, 0x05 ; 5
    7e56: ab 2e mov r10, r27
    boot_spm_busy_wait();


    #if defined(RWWSRE)
    // Reenable read access to flash
    boot_rww_enable();
    7e58: a1 e1 ldi r26, 0x11 ; 17
    7e5a: 9a 2e mov r9, r26
    do *bufPtr++ = getch();
    while (--length);


    // If we are in NRWW section, page erase has to be delayed until now.
    // Todo: Take RAMPZ into account
    if (address >= NRWWSTART) __boot_page_erase_short((uint16_t)(void*)address);
    7e5c: f3 e0 ldi r31, 0x03 ; 3
    7e5e: bf 2e mov r11, r31
    #endif


    /* Forever loop */
    for (;;) {
    /* get character from UART */
    ch = getch();
    7e60: a2 d0 rcall .+324 ; 0x7fa6 <getch>


    if(ch == STK_GET_PARAMETER) {
    7e62: 81 34 cpi r24, 0x41 ; 65
    7e64: 61 f4 brne .+24 ; 0x7e7e <main+0x7e>
    unsigned char which = getch();
    7e66: 9f d0 rcall .+318 ; 0x7fa6 <getch>
    7e68: 08 2f mov r16, r24
    verifySpace();
    7e6a: af d0 rcall .+350 ; 0x7fca <verifySpace>
    if (which == 0x82) {
    7e6c: 02 38 cpi r16, 0x82 ; 130
    7e6e: 11 f0 breq .+4 ; 0x7e74 <main+0x74>
    /*
    * Send optiboot version as "minor SW version"
    */
    putch(OPTIBOOT_MINVER);
    } else if (which == 0x81) {
    7e70: 01 38 cpi r16, 0x81 ; 129
    7e72: 11 f4 brne .+4 ; 0x7e78 <main+0x78>
    putch(OPTIBOOT_MAJVER);
    7e74: 84 e0 ldi r24, 0x04 ; 4
    7e76: 01 c0 rjmp .+2 ; 0x7e7a <main+0x7a>
    } else {
    /*
    * GET PARAMETER returns a generic 0x03 reply for
    * other parameters - enough to keep Avrdude happy
    */
    putch(0x03);
    7e78: 83 e0 ldi r24, 0x03 ; 3
    7e7a: 8d d0 rcall .+282 ; 0x7f96 <putch>
    7e7c: 89 c0 rjmp .+274 ; 0x7f90 <main+0x190>
    }
    }
    else if(ch == STK_SET_DEVICE) {
    7e7e: 82 34 cpi r24, 0x42 ; 66
    7e80: 11 f4 brne .+4 ; 0x7e86 <main+0x86>
    // SET DEVICE is ignored
    getNch(20);
    7e82: 84 e1 ldi r24, 0x14 ; 20
    7e84: 03 c0 rjmp .+6 ; 0x7e8c <main+0x8c>
    }
    else if(ch == STK_SET_DEVICE_EXT) {
    7e86: 85 34 cpi r24, 0x45 ; 69
    7e88: 19 f4 brne .+6 ; 0x7e90 <main+0x90>
    // SET DEVICE EXT is ignored
    getNch(5);
    7e8a: 85 e0 ldi r24, 0x05 ; 5
    7e8c: a6 d0 rcall .+332 ; 0x7fda <getNch>
    7e8e: 80 c0 rjmp .+256 ; 0x7f90 <main+0x190>
    }
    else if(ch == STK_LOAD_ADDRESS) {
    7e90: 85 35 cpi r24, 0x55 ; 85
    7e92: 79 f4 brne .+30 ; 0x7eb2 <main+0xb2>
    // LOAD ADDRESS
    uint16_t newAddress;
    newAddress = getch();
    7e94: 88 d0 rcall .+272 ; 0x7fa6 <getch>
    newAddress = (newAddress & 0xff) | (getch() << 8);
    7e96: e8 2e mov r14, r24
    7e98: ff 24 eor r15, r15
    7e9a: 85 d0 rcall .+266 ; 0x7fa6 <getch>
    7e9c: 08 2f mov r16, r24
    7e9e: 10 e0 ldi r17, 0x00 ; 0
    7ea0: 10 2f mov r17, r16
    7ea2: 00 27 eor r16, r16
    7ea4: 0e 29 or r16, r14
    7ea6: 1f 29 or r17, r15
    #ifdef RAMPZ
    // Transfer top bit to RAMPZ
    RAMPZ = (newAddress & 0x8000) ? 1 : 0;
    #endif
    newAddress += newAddress; // Convert from word address to byte address
    7ea8: 00 0f add r16, r16
    7eaa: 11 1f adc r17, r17
    address = newAddress;
    verifySpace();
    7eac: 8e d0 rcall .+284 ; 0x7fca <verifySpace>
    7eae: 68 01 movw r12, r16
    7eb0: 6f c0 rjmp .+222 ; 0x7f90 <main+0x190>
    }
    else if(ch == STK_UNIVERSAL) {
    7eb2: 86 35 cpi r24, 0x56 ; 86
    7eb4: 21 f4 brne .+8 ; 0x7ebe <main+0xbe>
    // UNIVERSAL command is ignored
    getNch(4);
    7eb6: 84 e0 ldi r24, 0x04 ; 4
    7eb8: 90 d0 rcall .+288 ; 0x7fda <getNch>
    putch(0x00);
    7eba: 80 e0 ldi r24, 0x00 ; 0
    7ebc: de cf rjmp .-68 ; 0x7e7a <main+0x7a>
    }
    /* Write memory, length is big endian and is in bytes */
    else if(ch == STK_PROG_PAGE) {
    7ebe: 84 36 cpi r24, 0x64 ; 100
    7ec0: 09 f0 breq .+2 ; 0x7ec4 <main+0xc4>
    7ec2: 40 c0 rjmp .+128 ; 0x7f44 <main+0x144>
    // PROGRAM PAGE - we support flash programming only, not EEPROM
    uint8_t *bufPtr;
    uint16_t addrPtr;


    getch(); /* getlen() */
    7ec4: 70 d0 rcall .+224 ; 0x7fa6 <getch>
    length = getch();
    7ec6: 6f d0 rcall .+222 ; 0x7fa6 <getch>
    7ec8: 08 2f mov r16, r24
    getch();
    7eca: 6d d0 rcall .+218 ; 0x7fa6 <getch>


    // If we are in RWW section, immediately start page erase
    if (address < NRWWSTART) __boot_page_erase_short((uint16_t)(void*)address);
    7ecc: 80 e0 ldi r24, 0x00 ; 0
    7ece: c8 16 cp r12, r24
    7ed0: 80 e7 ldi r24, 0x70 ; 112
    7ed2: d8 06 cpc r13, r24
    7ed4: 18 f4 brcc .+6 ; 0x7edc <main+0xdc>
    7ed6: f6 01 movw r30, r12
    7ed8: b7 be out 0x37, r11 ; 55
    7eda: e8 95 spm
    7edc: c0 e0 ldi r28, 0x00 ; 0
    7ede: d1 e0 ldi r29, 0x01 ; 1


    // While that is going on, read in page contents
    bufPtr = buff;
    do *bufPtr++ = getch();
    7ee0: 62 d0 rcall .+196 ; 0x7fa6 <getch>
    7ee2: 89 93 st Y+, r24
    while (--length);
    7ee4: 0c 17 cp r16, r28
    7ee6: e1 f7 brne .-8 ; 0x7ee0 <main+0xe0>


    // If we are in NRWW section, page erase has to be delayed until now.
    // Todo: Take RAMPZ into account
    if (address >= NRWWSTART) __boot_page_erase_short((uint16_t)(void*)address);
    7ee8: f0 e0 ldi r31, 0x00 ; 0
    7eea: cf 16 cp r12, r31
    7eec: f0 e7 ldi r31, 0x70 ; 112
    7eee: df 06 cpc r13, r31
    7ef0: 18 f0 brcs .+6 ; 0x7ef8 <main+0xf8>
    7ef2: f6 01 movw r30, r12
    7ef4: b7 be out 0x37, r11 ; 55
    7ef6: e8 95 spm


    // Read command terminator, start reply
    verifySpace();
    7ef8: 68 d0 rcall .+208 ; 0x7fca <verifySpace>


    // If only a partial page is to be programmed, the erase might not be complete.
    // So check that here
    boot_spm_busy_wait();
    7efa: 07 b6 in r0, 0x37 ; 55
    7efc: 00 fc sbrc r0, 0
    7efe: fd cf rjmp .-6 ; 0x7efa <main+0xfa>
    7f00: a6 01 movw r20, r12
    7f02: a0 e0 ldi r26, 0x00 ; 0
    7f04: b1 e0 ldi r27, 0x01 ; 1
    bufPtr = buff;
    addrPtr = (uint16_t)(void*)address;
    ch = SPM_PAGESIZE / 2;
    do {
    uint16_t a;
    a = *bufPtr++;
    7f06: 2c 91 ld r18, X
    7f08: 30 e0 ldi r19, 0x00 ; 0
    a |= (*bufPtr++) << 8;
    7f0a: 11 96 adiw r26, 0x01 ; 1
    7f0c: 8c 91 ld r24, X
    7f0e: 11 97 sbiw r26, 0x01 ; 1
    7f10: 90 e0 ldi r25, 0x00 ; 0
    7f12: 98 2f mov r25, r24
    7f14: 88 27 eor r24, r24
    7f16: 82 2b or r24, r18
    7f18: 93 2b or r25, r19
    #define rstVect (*(uint16_t*)(RAMSTART+SPM_PAGESIZE*2+4))
    #define wdtVect (*(uint16_t*)(RAMSTART+SPM_PAGESIZE*2+6))
    #endif


    /* main program starts here */
    int main(void) {
    7f1a: 12 96 adiw r26, 0x02 ; 2
    ch = SPM_PAGESIZE / 2;
    do {
    uint16_t a;
    a = *bufPtr++;
    a |= (*bufPtr++) << 8;
    __boot_page_fill_short((uint16_t)(void*)addrPtr,a);
    7f1c: fa 01 movw r30, r20
    7f1e: 0c 01 movw r0, r24
    7f20: 87 be out 0x37, r8 ; 55
    7f22: e8 95 spm
    7f24: 11 24 eor r1, r1
    addrPtr += 2;
    7f26: 4e 5f subi r20, 0xFE ; 254
    7f28: 5f 4f sbci r21, 0xFF ; 255
    } while (--ch);
    7f2a: f1 e0 ldi r31, 0x01 ; 1
    7f2c: a0 38 cpi r26, 0x80 ; 128
    7f2e: bf 07 cpc r27, r31
    7f30: 51 f7 brne .-44 ; 0x7f06 <main+0x106>


    // Write from programming buffer
    __boot_page_write_short((uint16_t)(void*)address);
    7f32: f6 01 movw r30, r12
    7f34: a7 be out 0x37, r10 ; 55
    7f36: e8 95 spm
    boot_spm_busy_wait();
    7f38: 07 b6 in r0, 0x37 ; 55
    7f3a: 00 fc sbrc r0, 0
    7f3c: fd cf rjmp .-6 ; 0x7f38 <main+0x138>


    #if defined(RWWSRE)
    // Reenable read access to flash
    boot_rww_enable();
    7f3e: 97 be out 0x37, r9 ; 55
    7f40: e8 95 spm
    7f42: 26 c0 rjmp .+76 ; 0x7f90 <main+0x190>
    #endif


    }
    /* Read memory block mode, length is big endian. */
    else if(ch == STK_READ_PAGE) {
    7f44: 84 37 cpi r24, 0x74 ; 116
    7f46: b1 f4 brne .+44 ; 0x7f74 <main+0x174>
    // READ PAGE - we only read flash
    getch(); /* getlen() */
    7f48: 2e d0 rcall .+92 ; 0x7fa6 <getch>
    length = getch();
    7f4a: 2d d0 rcall .+90 ; 0x7fa6 <getch>
    7f4c: f8 2e mov r15, r24
    getch();
    7f4e: 2b d0 rcall .+86 ; 0x7fa6 <getch>


    verifySpace();
    7f50: 3c d0 rcall .+120 ; 0x7fca <verifySpace>
    7f52: f6 01 movw r30, r12
    7f54: ef 2c mov r14, r15
    putch(result);
    address++;
    }
    while (--length);
    #else
    do putch(pgm_read_byte_near(address++));
    7f56: 8f 01 movw r16, r30
    7f58: 0f 5f subi r16, 0xFF ; 255
    7f5a: 1f 4f sbci r17, 0xFF ; 255
    7f5c: 84 91 lpm r24, Z+
    7f5e: 1b d0 rcall .+54 ; 0x7f96 <putch>
    while (--length);
    7f60: ea 94 dec r14
    7f62: f8 01 movw r30, r16
    7f64: c1 f7 brne .-16 ; 0x7f56 <main+0x156>
    #define rstVect (*(uint16_t*)(RAMSTART+SPM_PAGESIZE*2+4))
    #define wdtVect (*(uint16_t*)(RAMSTART+SPM_PAGESIZE*2+6))
    #endif


    /* main program starts here */
    int main(void) {
    7f66: 08 94 sec
    7f68: c1 1c adc r12, r1
    7f6a: d1 1c adc r13, r1
    7f6c: fa 94 dec r15
    7f6e: cf 0c add r12, r15
    7f70: d1 1c adc r13, r1
    7f72: 0e c0 rjmp .+28 ; 0x7f90 <main+0x190>
    #endif
    #endif
    }


    /* Get device signature bytes */
    else if(ch == STK_READ_SIGN) {
    7f74: 85 37 cpi r24, 0x75 ; 117
    7f76: 39 f4 brne .+14 ; 0x7f86 <main+0x186>
    // READ SIGN - return what Avrdude wants to hear
    verifySpace();
    7f78: 28 d0 rcall .+80 ; 0x7fca <verifySpace>
    putch(SIGNATURE_0);
    7f7a: 8e e1 ldi r24, 0x1E ; 30
    7f7c: 0c d0 rcall .+24 ; 0x7f96 <putch>
    putch(SIGNATURE_1);
    7f7e: 85 e9 ldi r24, 0x95 ; 149
    7f80: 0a d0 rcall .+20 ; 0x7f96 <putch>
    putch(SIGNATURE_2);
    7f82: 8f e0 ldi r24, 0x0F ; 15
    7f84: 7a cf rjmp .-268 ; 0x7e7a <main+0x7a>
    }
    else if (ch == 'Q') {
    7f86: 81 35 cpi r24, 0x51 ; 81
    7f88: 11 f4 brne .+4 ; 0x7f8e <main+0x18e>
    // Adaboot no-wait mod
    watchdogConfig(WATCHDOG_16MS);
    7f8a: 88 e0 ldi r24, 0x08 ; 8
    7f8c: 18 d0 rcall .+48 ; 0x7fbe <watchdogConfig>
    verifySpace();
    }
    else {
    // This covers the response to commands like STK_ENTER_PROGMODE
    verifySpace();
    7f8e: 1d d0 rcall .+58 ; 0x7fca <verifySpace>
    }
    putch(STK_OK);
    7f90: 80 e1 ldi r24, 0x10 ; 16
    7f92: 01 d0 rcall .+2 ; 0x7f96 <putch>
    7f94: 65 cf rjmp .-310 ; 0x7e60 <main+0x60>


    00007f96 <putch>:
    }
    }


    void putch(char ch) {
    7f96: 98 2f mov r25, r24
    #ifndef SOFT_UART
    while (!(UCSR0A & _BV(UDRE0)));
    7f98: 80 91 c0 00 lds r24, 0x00C0
    7f9c: 85 ff sbrs r24, 5
    7f9e: fc cf rjmp .-8 ; 0x7f98 <putch+0x2>
    UDR0 = ch;
    7fa0: 90 93 c6 00 sts 0x00C6, r25
    [uartBit] "I" (UART_TX_BIT)
    :
    "r25"
    );
    #endif
    }
    7fa4: 08 95 ret


    00007fa6 <getch>:
    [uartBit] "I" (UART_RX_BIT)
    :
    "r25"
    );
    #else
    while(!(UCSR0A & _BV(RXC0)))
    7fa6: 80 91 c0 00 lds r24, 0x00C0
    7faa: 87 ff sbrs r24, 7
    7fac: fc cf rjmp .-8 ; 0x7fa6 <getch>
    ;
    if (!(UCSR0A & _BV(FE0))) {
    7fae: 80 91 c0 00 lds r24, 0x00C0
    7fb2: 84 fd sbrc r24, 4
    7fb4: 01 c0 rjmp .+2 ; 0x7fb8 <getch+0x12>
    }
    #endif


    // Watchdog functions. These are only safe with interrupts turned off.
    void watchdogReset() {
    __asm__ __volatile__ (
    7fb6: a8 95 wdr
    * don't care that an invalid char is returned...)
    */
    watchdogReset();
    }

    ch = UDR0;
    7fb8: 80 91 c6 00 lds r24, 0x00C6
    LED_PIN |= _BV(LED);
    #endif
    #endif


    return ch;
    }
    7fbc: 08 95 ret


    00007fbe <watchdogConfig>:
    "wdr\n"
    );
    }


    void watchdogConfig(uint8_t x) {
    WDTCSR = _BV(WDCE) | _BV(WDE);
    7fbe: e0 e6 ldi r30, 0x60 ; 96
    7fc0: f0 e0 ldi r31, 0x00 ; 0
    7fc2: 98 e1 ldi r25, 0x18 ; 24
    7fc4: 90 83 st Z, r25
    WDTCSR = x;
    7fc6: 80 83 st Z, r24
    }
    7fc8: 08 95 ret


    00007fca <verifySpace>:
    do getch(); while (--count);
    verifySpace();
    }


    void verifySpace() {
    if (getch() != CRC_EOP) {
    7fca: ed df rcall .-38 ; 0x7fa6 <getch>
    7fcc: 80 32 cpi r24, 0x20 ; 32
    7fce: 19 f0 breq .+6 ; 0x7fd6 <verifySpace+0xc>
    watchdogConfig(WATCHDOG_16MS); // shorten WD timeout
    7fd0: 88 e0 ldi r24, 0x08 ; 8
    7fd2: f5 df rcall .-22 ; 0x7fbe <watchdogConfig>
    7fd4: ff cf rjmp .-2 ; 0x7fd4 <verifySpace+0xa>
    while (1) // and busy-loop so that WD causes
    ; // a reset and app start.
    }
    putch(STK_INSYNC);
    7fd6: 84 e1 ldi r24, 0x14 ; 20
    }
    7fd8: de cf rjmp .-68 ; 0x7f96 <putch>


    00007fda <getNch>:
    ::[count] "M" (UART_B_VALUE)
    );
    }
    #endif


    void getNch(uint8_t count) {
    7fda: 1f 93 push r17
    7fdc: 18 2f mov r17, r24
    do getch(); while (--count);
    7fde: e3 df rcall .-58 ; 0x7fa6 <getch>
    7fe0: 11 50 subi r17, 0x01 ; 1
    7fe2: e9 f7 brne .-6 ; 0x7fde <getNch+0x4>
    verifySpace();
    7fe4: f2 df rcall .-28 ; 0x7fca <verifySpace>
    }
    7fe6: 1f 91 pop r17
    7fe8: 08 95 ret


    00007fea <appStart>:
    WDTCSR = _BV(WDCE) | _BV(WDE);
    WDTCSR = x;
    }


    void appStart() {
    watchdogConfig(WATCHDOG_OFF);
    7fea: 80 e0 ldi r24, 0x00 ; 0
    7fec: e8 df rcall .-48 ; 0x7fbe <watchdogConfig>
    __asm__ __volatile__ (
    7fee: ee 27 eor r30, r30
    7ff0: ff 27 eor r31, r31
    7ff2: 09 94 ijmp







    فرق های زیادی ندارن! هسته یکیه فقط اینکه زمان روشن شدن(همون بوت شدن ) چند ثانیه فرق میکنه و حجم فضایی که میشه کد آپ کرد فرق میکنه و سرعت آپلود
    اینا رو نمیدونم چرا باید فرق کنه ولی احتمالا بر میگرده به استاندارد هایی که آردویینو برای این ماژول ها تایین کرده و محیطی که شاید باید توش کار کنن!مثلا من بوت لودر های مختلف رو روی 328 تست کردم و دیدم سرعت بوت فرق داره/ همچنین تعداد چشمک زدن چراغ قبل بوت فرق داره/ و حتی بوت لودر قدیمی مثلا UNO با بوت لودر جدیدش توی سرعت یه سری فرق هایی داره
    ویرایش توسط azjaguar : 2019/04/14 در ساعت 09:37






    امیرحسین ضیا
  5. #5
    2008/08/01
    26
    4

    پاسخ : تفاوت بوت لودرها

    این جزئیات که توی فایل board.txt هست انگار معرفی برد هست نه نشاندهنده قابلیت بیشتر.
    منم به این نتیجه رسیدم که تفاوتی در عملکرد نیست .اختلاف هایی مثل سرعت بوت چون گذرا است وتعداد چشمک برای من مهم نیست.هر وقت حجم حافظه کم میارم بوت لودر کم حجم تر میریزم تو 328.به نظر من این تفاوتها برای فنی ها فقط از نظر ابعاد برد مهمه .
    البته تفاوت بین ورژن پایینتر بوت لودر با ورژن جدیدتر قابل قبوله وطبیعیه که بهینه سازی بشه.
    ویرایش توسط electron329 : 2019/04/14 در ساعت 10:55
  6. #6
    2017/11/05
    Amol
    446
    158

    پاسخ : تفاوت بوت لودرها

    نقل قول نوشته اصلی توسط electron329

    مهمان عزیز شما حق دیدن لینک ها را ندارید

    عضویت

    این جزئیات که توی فایل board.txt هست انگار معرفی برد هست نه نشاندهنده قابلیت بیشتر.
    منم به این نتیجه رسیدم که تفاوتی در عملکرد نیست .اختلاف هایی مثل سرعت بوت چون گذرا است وتعداد چشمک برای من مهم نیست.هر وقت حجم حافظه کم میارم بوت لودر کم حجم تر میریزم تو 328.به نظر من این تفاوتها برای فنی ها فقط از نظر ابعاد برد مهمه .
    البته تفاوت بین ورژن پایینتر بوت لودر با ورژن جدیدتر قابل قبوله وطبیعیه که بهینه سازی بشه.
    ;کلا بوت لودر بیشتر به تنظیمات فیوز بیت اتمگا میپردازه که اینجا هم معرفی بورد نیست و نشان دهنده ی فیوز بیت ها مشخص کننده ی هسته ی مورد استفاده و فایلی که مربوط هست به اون ( پیوند دادن) میشه






    امیرحسین ضیا
نمایش نتایج: از 1 به 6 از 6

موضوعات مشابه

  1. تفاوت RAM و ROM
    توسط mostafa6369 در انجمن میکروکنترلرهای AVR
    پاسخ: 8
    آخرين نوشته: 2018/12/09, 09:43
  2. تفاوت vdd vcc vpp vee vss
    توسط mahdi89 در انجمن مدارهای آنالوگ و مدارهای مجتمع
    پاسخ: 1
    آخرين نوشته: 2015/11/17, 20:46
  3. ایا تفاوت رنگ مقاومت باعث تفاوت در وات است؟
    توسط ic 555 در انجمن مفاهیم پایه برق و الکترونیک
    پاسخ: 2
    آخرين نوشته: 2013/07/18, 08:21
  4. درباره بوت لودرها؟
    توسط alim2201 در انجمن پروسسورهای ARM
    پاسخ: 1
    آخرين نوشته: 2011/01/16, 12:32
  5. تفاوت AC و DC
    توسط mapmap در انجمن مدار هاي ديجيتال
    پاسخ: 1
    آخرين نوشته: 2010/08/31, 09:21

کلمات کلیدی این موضوع

علاقه مندي ها (Bookmarks)

علاقه مندي ها (Bookmarks)

مجوز های ارسال و ویرایش

  • شما نمیتوانید موضوع جدیدی ارسال کنید
  • شما امکان ارسال پاسخ را ندارید
  • شما نمیتوانید فایل پیوست کنید.
  • شما نمیتوانید پست های خود را ویرایش کنید
  •