как передать в функцию указатель на массив?
- Войдите на сайт для отправки комментариев
Ср, 19/08/2020 - 19:31
хочу скопировать один массив в другой. для этого запускаю цикл for
arr[8];
arr2[8] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
for(int i = 0; i < 8; i++){
arr[i] = arr2[i];
}
все работает прекрасно. но хочу сделать это функцией и передавать ссылку на массивы
void copyarr(byte *lincarr){
for(int i = 0; i < 8; i++){
arr[i] = lincarr[i];
}
}
тоже работает но памяти больше занимает. такое ощущение что не ссылку даю а массив копирую
а все же почему у меня память увеличивается?
а все же почему у меня память увеличивается?
приведите оба варианта кода, чтобы можно было скомпилировать и сравнить занимаемую память, теоретически обсуждать бессмысленно
void copyarr(byte *lincarr){ for(int i = 0; i < 8; i++){ arr[i] = lincarr[i]; } } ...... copyarr(arr2);Вы не передаёте ссылку, Вы передаёте указатель на 0-ой элемент.
приведите оба варианта кода, чтобы можно было скомпилировать и сравнить занимаемую память, теоретически обсуждать бессмысленно
byte arr[8]; byte arr1[8] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}; void copyarr(byte *linckarr){ for(int i = 0; i < 8; i++){ arr[i] = linckarr[i]; } if(arr[8] == 0x07) digitalWrite(0, 1); } void setup() { for(int i = 0; i < 8; i++){ arr[i] = arr1[i]; } if(arr[8] == 0x07) digitalWrite(0, 1); //copyarr(arr1); } void loop() { }вот так это занимает 8 байт а если через функцию то 16
код "через функцию" тоже выложите, чтобы нам не гадать
byte arr[8]; byte arr1[8] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}; void copyarr(byte *linckarr){ for(int i = 0; i < 8; i++){ arr[i] = linckarr[i]; } if(arr[8] == 0x07) digitalWrite(0, 1); } void setup() { // for(int i = 0; i < 8; i++){ // arr[i] = arr1[i]; // } //if(arr[8] == 0x07) digitalWrite(0, 1); copyarr(arr1); } void loop() { }вот тут уже 16 байт
del
вот тут уже 16 байт
А теперь давайте удалим откровенно бредовую строчку
(надеюсь, Вы понимаете, почему она бредовая)
И случится чудо:
byte arr[8]; byte arr1[8] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}; void setup() { for(int i = 0; i < 8; i++){ arr[i] = arr1[i]; } //if(arr[8] == 0x07) digitalWrite(0, 1); } void loop() {} -------------------------------- Скетч использует 444 байт (1%) памяти устройства. Всего доступно 32256 байт. Глобальные переменные используют 9 байт (0%) динамической памяти, оставляя 2039 байт для локальных переменных. Максимум: 2048 байт.и
byte arr[8]; byte arr1[8] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}; void copyarr(byte *linckarr){ for(int i = 0; i < 8; i++){ arr[i] = linckarr[i]; } //if(arr[8] == 0x07) digitalWrite(0, 1); } void setup() { copyarr(arr1); } void loop() {} ------------------------------- Скетч использует 444 байт (1%) памяти устройства. Всего доступно 32256 байт. Глобальные переменные используют 9 байт (0%) динамической памяти, оставляя 2039 байт для локальных переменных. Максимум: 2048 байт.Вот, как-то так :-)
да просто теперь компилятор понял что это все без толку и скомпилировал вырезав весь код
заметьте что код в обоих случаях одинаковый. но памяти занимает разно
Что значит одинаковый и что значит "разно".
Код у Вас неодинаковый.
А памяти без откровенного бреда занимает одинаково.
ну а в чем бред? в том что копировал и забыл исправить 8 на 7? или в том что смысла в нем нет?
так лучше?
так лучше?
С точки зрения бреда - лучше. С точки зрения памяти - одинаково
почему же меня не понять.
создайте массив byte arr3[8000000]; и попробуйте скомпилировать. скомпилировалось а памяти не убавилось. вот чудеса
Понятное дело - оптимизатор его выкинет, если в коде обращений не будет к элементам. Ловкость рук и никакого мошенства.
создайте массив byte arr3[8000000]; и попробуйте скомпилировать. скомпилировалось а памяти не убавилось. вот чудеса
Это Вы мне предлагаете? Ну, если Вы это понимаете, то зачем этот топик? Или только сейчас поняли?
В чём цимес-то?
почему же меня не понять.
создайте массив byte arr3[8000000]; и попробуйте скомпилировать. скомпилировалось а памяти не убавилось. вот чудеса
так вы не просто массив создайте, а попробуйте что-нибудь с ним сделать - все сразу станет ясно
так вот именно для этого я и написал
byte arr[8]; byte arr1[8] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}; void copyarr(byte *linckarr) { for (int i = 0; i < 8; i++) { arr[i] = linckarr[i]; } } void setup() { Serial.begin(9600); for(int i = 0; i < 8; i++){ arr[i] = arr1[i]; } // copyarr(arr1); } void loop() { for (int i = 0; i < 8; i++) { Serial.print(arr1[i]); } Serial.println(); } Скетч использует 1670 байт (5%) памяти устройства. Всего доступно 32256 байт. Глобальные переменные используют 196 байт (9%) динамической памяти, оставляя 1852 байт для локальных переменных. Максимум: 2048 байт.-------------------------
byte arr[8]; byte arr1[8] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}; void copyarr(byte *linckarr) { for (int i = 0; i < 8; i++) { arr[i] = linckarr[i]; } } void setup() { Serial.begin(9600); // for(int i = 0; i < 8; i++){ // arr[i] = arr1[i]; // } copyarr(arr1); } void loop() { for (int i = 0; i < 8; i++) { Serial.print(arr1[i]); } Serial.println(); } Скетч использует 1670 байт (5%) памяти устройства. Всего доступно 32256 байт. Глобальные переменные используют 196 байт (9%) динамической памяти, оставляя 1852 байт для локальных переменных. Максимум: 2048 байт.давайте немного по другому. с точки зрения компилятора вот этот код (плохой, бесполезный, ненужный это все понятно) -
byte arr[8]; byte arr1[8] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}; void copyarr(byte *linkarr){ for(int i = 0; i < 8; i++){ arr[i] = linkarr[i]; } if(arr[7] == 0x07) digitalWrite(0, 1); } void setup() { copyarr(arr1); } void loop() { }аналогичен вот этому ?
byte arr[8]; byte arr1[8] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}; void setup() { for(int i = 0; i < 8; i++){ arr[i] = arr1[i]; } if(arr[7] == 0x07) digitalWrite(0, 1); } void loop() { }тогда почему память занята разная?
Полагаю потому, что: Вы передаёте в функцию КОПИЮ массива, а не сам массив. Сам массив передают по ссылке.
будьте добры подскажите как правильно
Вот мы щас все бросим и начнем гадать, какие паттерны у оптимизатора отрабатывают.
А так я только последний вопрос прочёл, и не знаю что Вам нужно в итоге. Если просто передать массив целиком в функцию - так используйте адрес, а не указатель. А точнее это называется «разименование адреса» (простите гуру, если не верно написал).
давайте немного по другому.
Постом выше я ваш же код и привел. Вам же все равно строка с записью в нулевой пин не нужна. А без нее память расходуется абсолютно одинаково
только вопрос почему с ней же второй код на 8 байт короче остается не разгаданным
Вопрос конечно интересный ;) https://tsibrov.blogspot.com/2019/06/ide-arduino-disassembling.html
без функции:
C:\HEX/bred.ino.elf: file format elf32-avr Disassembly of section .text: 00000000 <__vectors>: 0: 0c 94 57 00 jmp 0xae ; 0xae <__ctors_end> 4: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 8: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> c: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 10: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 14: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 18: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 1c: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 20: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 24: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 28: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 2c: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 30: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 34: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 38: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 3c: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 40: 0c 94 6b 00 jmp 0xd6 ; 0xd6 <__vector_16> 44: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 48: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 4c: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 50: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 54: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 58: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 5c: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 60: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 64: 0c 94 69 00 jmp 0xd2 ; 0xd2 <__bad_interrupt> 00000068 <__trampolines_end>: 68: 00 00 nop 6a: 00 00 nop 6c: 25 00 .word 0x0025 ; ???? 6e: 28 00 .word 0x0028 ; ???? 70: 2b 00 .word 0x002b ; ???? 00000072 <digital_pin_to_port_PGM>: 72: 04 04 04 04 04 04 04 04 02 02 02 02 02 02 03 03 ................ 82: 03 03 03 03 .... 00000086 <digital_pin_to_bit_mask_PGM>: 86: 01 02 04 08 10 20 40 80 01 02 04 08 10 20 01 02 ..... @...... .. 96: 04 08 10 20 ... 0000009a <digital_pin_to_timer_PGM>: 9a: 00 00 00 08 00 02 01 00 00 03 04 07 00 00 00 00 ................ aa: 00 00 00 00 .... 000000ae <__ctors_end>: ae: 11 24 eor r1, r1 b0: 1f be out 0x3f, r1 ; 63 b2: cf ef ldi r28, 0xFF ; 255 b4: d8 e0 ldi r29, 0x08 ; 8 b6: de bf out 0x3e, r29 ; 62 b8: cd bf out 0x3d, r28 ; 61 000000ba <__do_clear_bss>: ba: 21 e0 ldi r18, 0x01 ; 1 bc: a0 e0 ldi r26, 0x00 ; 0 be: b1 e0 ldi r27, 0x01 ; 1 c0: 01 c0 rjmp .+2 ; 0xc4 <.do_clear_bss_start> 000000c2 <.do_clear_bss_loop>: c2: 1d 92 st X+, r1 000000c4 <.do_clear_bss_start>: c4: a1 31 cpi r26, 0x11 ; 17 c6: b2 07 cpc r27, r18 c8: e1 f7 brne .-8 ; 0xc2 <.do_clear_bss_loop> ca: 0e 94 b5 00 call 0x16a ; 0x16a <main> ce: 0c 94 58 01 jmp 0x2b0 ; 0x2b0 <_exit> 000000d2 <__bad_interrupt>: d2: 0c 94 00 00 jmp 0 ; 0x0 <__vectors> 000000d6 <__vector_16>: #if defined(TIM0_OVF_vect) ISR(TIM0_OVF_vect) #else ISR(TIMER0_OVF_vect) #endif { d6: 1f 92 push r1 d8: 0f 92 push r0 da: 0f b6 in r0, 0x3f ; 63 dc: 0f 92 push r0 de: 11 24 eor r1, r1 e0: 2f 93 push r18 e2: 3f 93 push r19 e4: 8f 93 push r24 e6: 9f 93 push r25 e8: af 93 push r26 ea: bf 93 push r27 // copy these to local variables so they can be stored in registers // (volatile variables must be read from memory on every access) unsigned long m = timer0_millis; ec: 80 91 0d 01 lds r24, 0x010D ; 0x80010d <timer0_millis> f0: 90 91 0e 01 lds r25, 0x010E ; 0x80010e <timer0_millis+0x1> f4: a0 91 0f 01 lds r26, 0x010F ; 0x80010f <timer0_millis+0x2> f8: b0 91 10 01 lds r27, 0x0110 ; 0x800110 <timer0_millis+0x3> unsigned char f = timer0_fract; fc: 30 91 0c 01 lds r19, 0x010C ; 0x80010c <timer0_fract> m += MILLIS_INC; f += FRACT_INC; 100: 23 e0 ldi r18, 0x03 ; 3 102: 23 0f add r18, r19 if (f >= FRACT_MAX) { 104: 2d 37 cpi r18, 0x7D ; 125 106: 58 f5 brcc .+86 ; 0x15e <__vector_16+0x88> // copy these to local variables so they can be stored in registers // (volatile variables must be read from memory on every access) unsigned long m = timer0_millis; unsigned char f = timer0_fract; m += MILLIS_INC; 108: 01 96 adiw r24, 0x01 ; 1 10a: a1 1d adc r26, r1 10c: b1 1d adc r27, r1 if (f >= FRACT_MAX) { f -= FRACT_MAX; m += 1; } timer0_fract = f; 10e: 20 93 0c 01 sts 0x010C, r18 ; 0x80010c <timer0_fract> timer0_millis = m; 112: 80 93 0d 01 sts 0x010D, r24 ; 0x80010d <timer0_millis> 116: 90 93 0e 01 sts 0x010E, r25 ; 0x80010e <timer0_millis+0x1> 11a: a0 93 0f 01 sts 0x010F, r26 ; 0x80010f <timer0_millis+0x2> 11e: b0 93 10 01 sts 0x0110, r27 ; 0x800110 <timer0_millis+0x3> timer0_overflow_count++; 122: 80 91 08 01 lds r24, 0x0108 ; 0x800108 <timer0_overflow_count> 126: 90 91 09 01 lds r25, 0x0109 ; 0x800109 <timer0_overflow_count+0x1> 12a: a0 91 0a 01 lds r26, 0x010A ; 0x80010a <timer0_overflow_count+0x2> 12e: b0 91 0b 01 lds r27, 0x010B ; 0x80010b <timer0_overflow_count+0x3> 132: 01 96 adiw r24, 0x01 ; 1 134: a1 1d adc r26, r1 136: b1 1d adc r27, r1 138: 80 93 08 01 sts 0x0108, r24 ; 0x800108 <timer0_overflow_count> 13c: 90 93 09 01 sts 0x0109, r25 ; 0x800109 <timer0_overflow_count+0x1> 140: a0 93 0a 01 sts 0x010A, r26 ; 0x80010a <timer0_overflow_count+0x2> 144: b0 93 0b 01 sts 0x010B, r27 ; 0x80010b <timer0_overflow_count+0x3> } 148: bf 91 pop r27 14a: af 91 pop r26 14c: 9f 91 pop r25 14e: 8f 91 pop r24 150: 3f 91 pop r19 152: 2f 91 pop r18 154: 0f 90 pop r0 156: 0f be out 0x3f, r0 ; 63 158: 0f 90 pop r0 15a: 1f 90 pop r1 15c: 18 95 reti unsigned char f = timer0_fract; m += MILLIS_INC; f += FRACT_INC; if (f >= FRACT_MAX) { f -= FRACT_MAX; 15e: 26 e8 ldi r18, 0x86 ; 134 160: 23 0f add r18, r19 m += 1; 162: 02 96 adiw r24, 0x02 ; 2 164: a1 1d adc r26, r1 166: b1 1d adc r27, r1 168: d2 cf rjmp .-92 ; 0x10e <__vector_16+0x38> 0000016a <main>: void init() { // this needs to be called before setup() or some functions won't // work there sei(); 16a: 78 94 sei // on the ATmega168, timer 0 is also used for fast hardware pwm // (using phase-correct PWM would mean that timer 0 overflowed half as often // resulting in different millis() behavior on the ATmega8 and ATmega168) #if defined(TCCR0A) && defined(WGM01) sbi(TCCR0A, WGM01); 16c: 84 b5 in r24, 0x24 ; 36 16e: 82 60 ori r24, 0x02 ; 2 170: 84 bd out 0x24, r24 ; 36 sbi(TCCR0A, WGM00); 172: 84 b5 in r24, 0x24 ; 36 174: 81 60 ori r24, 0x01 ; 1 176: 84 bd out 0x24, r24 ; 36 // this combination is for the standard atmega8 sbi(TCCR0, CS01); sbi(TCCR0, CS00); #elif defined(TCCR0B) && defined(CS01) && defined(CS00) // this combination is for the standard 168/328/1280/2560 sbi(TCCR0B, CS01); 178: 85 b5 in r24, 0x25 ; 37 17a: 82 60 ori r24, 0x02 ; 2 17c: 85 bd out 0x25, r24 ; 37 sbi(TCCR0B, CS00); 17e: 85 b5 in r24, 0x25 ; 37 180: 81 60 ori r24, 0x01 ; 1 182: 85 bd out 0x25, r24 ; 37 // enable timer 0 overflow interrupt #if defined(TIMSK) && defined(TOIE0) sbi(TIMSK, TOIE0); #elif defined(TIMSK0) && defined(TOIE0) sbi(TIMSK0, TOIE0); 184: 80 91 6e 00 lds r24, 0x006E ; 0x80006e <__TEXT_REGION_LENGTH__+0x7e006e> 188: 81 60 ori r24, 0x01 ; 1 18a: 80 93 6e 00 sts 0x006E, r24 ; 0x80006e <__TEXT_REGION_LENGTH__+0x7e006e> // this is better for motors as it ensures an even waveform // note, however, that fast pwm mode can achieve a frequency of up // 8 MHz (with a 16 MHz clock) at 50% duty cycle #if defined(TCCR1B) && defined(CS11) && defined(CS10) TCCR1B = 0; 18e: 10 92 81 00 sts 0x0081, r1 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> // set timer 1 prescale factor to 64 sbi(TCCR1B, CS11); 192: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> 196: 82 60 ori r24, 0x02 ; 2 198: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> #if F_CPU >= 8000000L sbi(TCCR1B, CS10); 19c: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> 1a0: 81 60 ori r24, 0x01 ; 1 1a2: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> sbi(TCCR1, CS10); #endif #endif // put timer 1 in 8-bit phase correct pwm mode #if defined(TCCR1A) && defined(WGM10) sbi(TCCR1A, WGM10); 1a6: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> 1aa: 81 60 ori r24, 0x01 ; 1 1ac: 80 93 80 00 sts 0x0080, r24 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> // set timer 2 prescale factor to 64 #if defined(TCCR2) && defined(CS22) sbi(TCCR2, CS22); #elif defined(TCCR2B) && defined(CS22) sbi(TCCR2B, CS22); 1b0: 80 91 b1 00 lds r24, 0x00B1 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1> 1b4: 84 60 ori r24, 0x04 ; 4 1b6: 80 93 b1 00 sts 0x00B1, r24 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1> // configure timer 2 for phase correct pwm (8-bit) #if defined(TCCR2) && defined(WGM20) sbi(TCCR2, WGM20); #elif defined(TCCR2A) && defined(WGM20) sbi(TCCR2A, WGM20); 1ba: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> 1be: 81 60 ori r24, 0x01 ; 1 1c0: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> #endif #if defined(ADCSRA) // set a2d prescaler so we are inside the desired 50-200 KHz range. #if F_CPU >= 16000000 // 16 MHz / 128 = 125 KHz sbi(ADCSRA, ADPS2); 1c4: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> 1c8: 84 60 ori r24, 0x04 ; 4 1ca: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> sbi(ADCSRA, ADPS1); 1ce: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> 1d2: 82 60 ori r24, 0x02 ; 2 1d4: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> sbi(ADCSRA, ADPS0); 1d8: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> 1dc: 81 60 ori r24, 0x01 ; 1 1de: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> cbi(ADCSRA, ADPS2); cbi(ADCSRA, ADPS1); sbi(ADCSRA, ADPS0); #endif // enable a2d conversions sbi(ADCSRA, ADEN); 1e2: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> 1e6: 80 68 ori r24, 0x80 ; 128 1e8: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> // here so they can be used as normal digital i/o; they will be // reconnected in Serial.begin() #if defined(UCSRB) UCSRB = 0; #elif defined(UCSR0B) UCSR0B = 0; 1ec: 10 92 c1 00 sts 0x00C1, r1 ; 0x8000c1 <__TEXT_REGION_LENGTH__+0x7e00c1> byte arr[8]; byte arr1[8] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}; void setup() { for(int i = 0; i < 8; i++){ arr[i] = arr1[i]; 1f0: 10 92 00 01 sts 0x0100, r1 ; 0x800100 <_edata> 1f4: 81 e0 ldi r24, 0x01 ; 1 1f6: 80 93 01 01 sts 0x0101, r24 ; 0x800101 <_edata+0x1> 1fa: 82 e0 ldi r24, 0x02 ; 2 1fc: 80 93 02 01 sts 0x0102, r24 ; 0x800102 <_edata+0x2> 200: 83 e0 ldi r24, 0x03 ; 3 202: 80 93 03 01 sts 0x0103, r24 ; 0x800103 <_edata+0x3> 206: 84 e0 ldi r24, 0x04 ; 4 208: 80 93 04 01 sts 0x0104, r24 ; 0x800104 <_edata+0x4> 20c: 85 e0 ldi r24, 0x05 ; 5 20e: 80 93 05 01 sts 0x0105, r24 ; 0x800105 <_edata+0x5> 212: 86 e0 ldi r24, 0x06 ; 6 214: 80 93 06 01 sts 0x0106, r24 ; 0x800106 <_edata+0x6> 218: 87 e0 ldi r24, 0x07 ; 7 21a: 80 93 07 01 sts 0x0107, r24 ; 0x800107 <_edata+0x7> } } void digitalWrite(uint8_t pin, uint8_t val) { uint8_t timer = digitalPinToTimer(pin); 21e: ea e9 ldi r30, 0x9A ; 154 220: f0 e0 ldi r31, 0x00 ; 0 222: 84 91 lpm r24, Z uint8_t bit = digitalPinToBitMask(pin); 224: e6 e8 ldi r30, 0x86 ; 134 226: f0 e0 ldi r31, 0x00 ; 0 228: 94 91 lpm r25, Z uint8_t port = digitalPinToPort(pin); 22a: e2 e7 ldi r30, 0x72 ; 114 22c: f0 e0 ldi r31, 0x00 ; 0 22e: e4 91 lpm r30, Z volatile uint8_t *out; if (port == NOT_A_PIN) return; 230: ee 23 and r30, r30 232: b1 f0 breq .+44 ; 0x260 <main+0xf6> // If the pin that support PWM output, we need to turn it off // before doing a digital write. if (timer != NOT_ON_TIMER) turnOffPWM(timer); 234: 88 23 and r24, r24 236: 39 f0 breq .+14 ; 0x246 <main+0xdc> // //static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline)); //static inline void turnOffPWM(uint8_t timer) static void turnOffPWM(uint8_t timer) { switch (timer) 238: 83 30 cpi r24, 0x03 ; 3 23a: 19 f1 breq .+70 ; 0x282 <main+0x118> 23c: c0 f4 brcc .+48 ; 0x26e <main+0x104> 23e: 81 30 cpi r24, 0x01 ; 1 240: 31 f1 breq .+76 ; 0x28e <main+0x124> 242: 82 30 cpi r24, 0x02 ; 2 244: 41 f1 breq .+80 ; 0x296 <main+0x12c> // If the pin that support PWM output, we need to turn it off // before doing a digital write. if (timer != NOT_ON_TIMER) turnOffPWM(timer); out = portOutputRegister(port); 246: f0 e0 ldi r31, 0x00 ; 0 248: ee 0f add r30, r30 24a: ff 1f adc r31, r31 24c: e8 59 subi r30, 0x98 ; 152 24e: ff 4f sbci r31, 0xFF ; 255 250: a5 91 lpm r26, Z+ 252: b4 91 lpm r27, Z uint8_t oldSREG = SREG; 254: 8f b7 in r24, 0x3f ; 63 cli(); 256: f8 94 cli if (val == LOW) { *out &= ~bit; } else { *out |= bit; 258: ec 91 ld r30, X 25a: 9e 2b or r25, r30 25c: 9c 93 st X, r25 } SREG = oldSREG; 25e: 8f bf out 0x3f, r24 ; 63 setup(); for (;;) { loop(); if (serialEventRun) serialEventRun(); 260: c0 e0 ldi r28, 0x00 ; 0 262: d0 e0 ldi r29, 0x00 ; 0 264: 20 97 sbiw r28, 0x00 ; 0 266: f1 f3 breq .-4 ; 0x264 <main+0xfa> 268: 0e 94 00 00 call 0 ; 0x0 <__vectors> 26c: fb cf rjmp .-10 ; 0x264 <main+0xfa> // //static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline)); //static inline void turnOffPWM(uint8_t timer) static void turnOffPWM(uint8_t timer) { switch (timer) 26e: 87 30 cpi r24, 0x07 ; 7 270: a9 f0 breq .+42 ; 0x29c <main+0x132> 272: 88 30 cpi r24, 0x08 ; 8 274: c9 f0 breq .+50 ; 0x2a8 <main+0x13e> 276: 84 30 cpi r24, 0x04 ; 4 278: 31 f7 brne .-52 ; 0x246 <main+0xdc> { #if defined(TCCR1A) && defined(COM1A1) case TIMER1A: cbi(TCCR1A, COM1A1); break; #endif #if defined(TCCR1A) && defined(COM1B1) case TIMER1B: cbi(TCCR1A, COM1B1); break; 27a: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> 27e: 8f 7d andi r24, 0xDF ; 223 280: 03 c0 rjmp .+6 ; 0x288 <main+0x11e> static void turnOffPWM(uint8_t timer) { switch (timer) { #if defined(TCCR1A) && defined(COM1A1) case TIMER1A: cbi(TCCR1A, COM1A1); break; 282: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> 286: 8f 77 andi r24, 0x7F ; 127 #endif #if defined(TCCR1A) && defined(COM1B1) case TIMER1B: cbi(TCCR1A, COM1B1); break; 288: 80 93 80 00 sts 0x0080, r24 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> 28c: dc cf rjmp .-72 ; 0x246 <main+0xdc> #if defined(TCCR2) && defined(COM21) case TIMER2: cbi(TCCR2, COM21); break; #endif #if defined(TCCR0A) && defined(COM0A1) case TIMER0A: cbi(TCCR0A, COM0A1); break; 28e: 84 b5 in r24, 0x24 ; 36 290: 8f 77 andi r24, 0x7F ; 127 #endif #if defined(TCCR0A) && defined(COM0B1) case TIMER0B: cbi(TCCR0A, COM0B1); break; 292: 84 bd out 0x24, r24 ; 36 294: d8 cf rjmp .-80 ; 0x246 <main+0xdc> 296: 84 b5 in r24, 0x24 ; 36 298: 8f 7d andi r24, 0xDF ; 223 29a: fb cf rjmp .-10 ; 0x292 <main+0x128> #endif #if defined(TCCR2A) && defined(COM2A1) case TIMER2A: cbi(TCCR2A, COM2A1); break; 29c: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> 2a0: 8f 77 andi r24, 0x7F ; 127 #endif #if defined(TCCR2A) && defined(COM2B1) case TIMER2B: cbi(TCCR2A, COM2B1); break; 2a2: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> 2a6: cf cf rjmp .-98 ; 0x246 <main+0xdc> 2a8: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> 2ac: 8f 7d andi r24, 0xDF ; 223 2ae: f9 cf rjmp .-14 ; 0x2a2 <main+0x138> 000002b0 <_exit>: 2b0: f8 94 cli 000002b2 <__stop_program>: 2b2: ff cf rjmp .-2 ; 0x2b2 <__stop_program>С функцией копирования:
C:\HEX/bred.ino.elf: file format elf32-avr Disassembly of section .text: 00000000 <__vectors>: 0: 0c 94 57 00 jmp 0xae ; 0xae <__ctors_end> 4: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 8: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> c: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 10: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 14: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 18: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 1c: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 20: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 24: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 28: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 2c: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 30: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 34: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 38: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 3c: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 40: 0c 94 76 00 jmp 0xec ; 0xec <__vector_16> 44: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 48: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 4c: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 50: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 54: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 58: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 5c: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 60: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 64: 0c 94 74 00 jmp 0xe8 ; 0xe8 <__bad_interrupt> 00000068 <__trampolines_end>: 68: 00 00 nop 6a: 00 00 nop 6c: 25 00 .word 0x0025 ; ???? 6e: 28 00 .word 0x0028 ; ???? 70: 2b 00 .word 0x002b ; ???? 00000072 <digital_pin_to_port_PGM>: 72: 04 04 04 04 04 04 04 04 02 02 02 02 02 02 03 03 ................ 82: 03 03 03 03 .... 00000086 <digital_pin_to_bit_mask_PGM>: 86: 01 02 04 08 10 20 40 80 01 02 04 08 10 20 01 02 ..... @...... .. 96: 04 08 10 20 ... 0000009a <digital_pin_to_timer_PGM>: 9a: 00 00 00 08 00 02 01 00 00 03 04 07 00 00 00 00 ................ aa: 00 00 00 00 .... 000000ae <__ctors_end>: ae: 11 24 eor r1, r1 b0: 1f be out 0x3f, r1 ; 63 b2: cf ef ldi r28, 0xFF ; 255 b4: d8 e0 ldi r29, 0x08 ; 8 b6: de bf out 0x3e, r29 ; 62 b8: cd bf out 0x3d, r28 ; 61 000000ba <__do_copy_data>: ba: 11 e0 ldi r17, 0x01 ; 1 bc: a0 e0 ldi r26, 0x00 ; 0 be: b1 e0 ldi r27, 0x01 ; 1 c0: ea eb ldi r30, 0xBA ; 186 c2: f2 e0 ldi r31, 0x02 ; 2 c4: 02 c0 rjmp .+4 ; 0xca <__do_copy_data+0x10> c6: 05 90 lpm r0, Z+ c8: 0d 92 st X+, r0 ca: a8 30 cpi r26, 0x08 ; 8 cc: b1 07 cpc r27, r17 ce: d9 f7 brne .-10 ; 0xc6 <__do_copy_data+0xc> 000000d0 <__do_clear_bss>: d0: 21 e0 ldi r18, 0x01 ; 1 d2: a8 e0 ldi r26, 0x08 ; 8 d4: b1 e0 ldi r27, 0x01 ; 1 d6: 01 c0 rjmp .+2 ; 0xda <.do_clear_bss_start> 000000d8 <.do_clear_bss_loop>: d8: 1d 92 st X+, r1 000000da <.do_clear_bss_start>: da: a9 31 cpi r26, 0x19 ; 25 dc: b2 07 cpc r27, r18 de: e1 f7 brne .-8 ; 0xd8 <.do_clear_bss_loop> e0: 0e 94 c0 00 call 0x180 ; 0x180 <main> e4: 0c 94 5b 01 jmp 0x2b6 ; 0x2b6 <_exit> 000000e8 <__bad_interrupt>: e8: 0c 94 00 00 jmp 0 ; 0x0 <__vectors> 000000ec <__vector_16>: #if defined(TIM0_OVF_vect) ISR(TIM0_OVF_vect) #else ISR(TIMER0_OVF_vect) #endif { ec: 1f 92 push r1 ee: 0f 92 push r0 f0: 0f b6 in r0, 0x3f ; 63 f2: 0f 92 push r0 f4: 11 24 eor r1, r1 f6: 2f 93 push r18 f8: 3f 93 push r19 fa: 8f 93 push r24 fc: 9f 93 push r25 fe: af 93 push r26 100: bf 93 push r27 // copy these to local variables so they can be stored in registers // (volatile variables must be read from memory on every access) unsigned long m = timer0_millis; 102: 80 91 15 01 lds r24, 0x0115 ; 0x800115 <timer0_millis> 106: 90 91 16 01 lds r25, 0x0116 ; 0x800116 <timer0_millis+0x1> 10a: a0 91 17 01 lds r26, 0x0117 ; 0x800117 <timer0_millis+0x2> 10e: b0 91 18 01 lds r27, 0x0118 ; 0x800118 <timer0_millis+0x3> unsigned char f = timer0_fract; 112: 30 91 14 01 lds r19, 0x0114 ; 0x800114 <timer0_fract> m += MILLIS_INC; f += FRACT_INC; 116: 23 e0 ldi r18, 0x03 ; 3 118: 23 0f add r18, r19 if (f >= FRACT_MAX) { 11a: 2d 37 cpi r18, 0x7D ; 125 11c: 58 f5 brcc .+86 ; 0x174 <__vector_16+0x88> // copy these to local variables so they can be stored in registers // (volatile variables must be read from memory on every access) unsigned long m = timer0_millis; unsigned char f = timer0_fract; m += MILLIS_INC; 11e: 01 96 adiw r24, 0x01 ; 1 120: a1 1d adc r26, r1 122: b1 1d adc r27, r1 if (f >= FRACT_MAX) { f -= FRACT_MAX; m += 1; } timer0_fract = f; 124: 20 93 14 01 sts 0x0114, r18 ; 0x800114 <timer0_fract> timer0_millis = m; 128: 80 93 15 01 sts 0x0115, r24 ; 0x800115 <timer0_millis> 12c: 90 93 16 01 sts 0x0116, r25 ; 0x800116 <timer0_millis+0x1> 130: a0 93 17 01 sts 0x0117, r26 ; 0x800117 <timer0_millis+0x2> 134: b0 93 18 01 sts 0x0118, r27 ; 0x800118 <timer0_millis+0x3> timer0_overflow_count++; 138: 80 91 10 01 lds r24, 0x0110 ; 0x800110 <timer0_overflow_count> 13c: 90 91 11 01 lds r25, 0x0111 ; 0x800111 <timer0_overflow_count+0x1> 140: a0 91 12 01 lds r26, 0x0112 ; 0x800112 <timer0_overflow_count+0x2> 144: b0 91 13 01 lds r27, 0x0113 ; 0x800113 <timer0_overflow_count+0x3> 148: 01 96 adiw r24, 0x01 ; 1 14a: a1 1d adc r26, r1 14c: b1 1d adc r27, r1 14e: 80 93 10 01 sts 0x0110, r24 ; 0x800110 <timer0_overflow_count> 152: 90 93 11 01 sts 0x0111, r25 ; 0x800111 <timer0_overflow_count+0x1> 156: a0 93 12 01 sts 0x0112, r26 ; 0x800112 <timer0_overflow_count+0x2> 15a: b0 93 13 01 sts 0x0113, r27 ; 0x800113 <timer0_overflow_count+0x3> } 15e: bf 91 pop r27 160: af 91 pop r26 162: 9f 91 pop r25 164: 8f 91 pop r24 166: 3f 91 pop r19 168: 2f 91 pop r18 16a: 0f 90 pop r0 16c: 0f be out 0x3f, r0 ; 63 16e: 0f 90 pop r0 170: 1f 90 pop r1 172: 18 95 reti unsigned char f = timer0_fract; m += MILLIS_INC; f += FRACT_INC; if (f >= FRACT_MAX) { f -= FRACT_MAX; 174: 26 e8 ldi r18, 0x86 ; 134 176: 23 0f add r18, r19 m += 1; 178: 02 96 adiw r24, 0x02 ; 2 17a: a1 1d adc r26, r1 17c: b1 1d adc r27, r1 17e: d2 cf rjmp .-92 ; 0x124 <__vector_16+0x38> 00000180 <main>: void init() { // this needs to be called before setup() or some functions won't // work there sei(); 180: 78 94 sei // on the ATmega168, timer 0 is also used for fast hardware pwm // (using phase-correct PWM would mean that timer 0 overflowed half as often // resulting in different millis() behavior on the ATmega8 and ATmega168) #if defined(TCCR0A) && defined(WGM01) sbi(TCCR0A, WGM01); 182: 84 b5 in r24, 0x24 ; 36 184: 82 60 ori r24, 0x02 ; 2 186: 84 bd out 0x24, r24 ; 36 sbi(TCCR0A, WGM00); 188: 84 b5 in r24, 0x24 ; 36 18a: 81 60 ori r24, 0x01 ; 1 18c: 84 bd out 0x24, r24 ; 36 // this combination is for the standard atmega8 sbi(TCCR0, CS01); sbi(TCCR0, CS00); #elif defined(TCCR0B) && defined(CS01) && defined(CS00) // this combination is for the standard 168/328/1280/2560 sbi(TCCR0B, CS01); 18e: 85 b5 in r24, 0x25 ; 37 190: 82 60 ori r24, 0x02 ; 2 192: 85 bd out 0x25, r24 ; 37 sbi(TCCR0B, CS00); 194: 85 b5 in r24, 0x25 ; 37 196: 81 60 ori r24, 0x01 ; 1 198: 85 bd out 0x25, r24 ; 37 // enable timer 0 overflow interrupt #if defined(TIMSK) && defined(TOIE0) sbi(TIMSK, TOIE0); #elif defined(TIMSK0) && defined(TOIE0) sbi(TIMSK0, TOIE0); 19a: 80 91 6e 00 lds r24, 0x006E ; 0x80006e <__TEXT_REGION_LENGTH__+0x7e006e> 19e: 81 60 ori r24, 0x01 ; 1 1a0: 80 93 6e 00 sts 0x006E, r24 ; 0x80006e <__TEXT_REGION_LENGTH__+0x7e006e> // this is better for motors as it ensures an even waveform // note, however, that fast pwm mode can achieve a frequency of up // 8 MHz (with a 16 MHz clock) at 50% duty cycle #if defined(TCCR1B) && defined(CS11) && defined(CS10) TCCR1B = 0; 1a4: 10 92 81 00 sts 0x0081, r1 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> // set timer 1 prescale factor to 64 sbi(TCCR1B, CS11); 1a8: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> 1ac: 82 60 ori r24, 0x02 ; 2 1ae: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> #if F_CPU >= 8000000L sbi(TCCR1B, CS10); 1b2: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> 1b6: 81 60 ori r24, 0x01 ; 1 1b8: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> sbi(TCCR1, CS10); #endif #endif // put timer 1 in 8-bit phase correct pwm mode #if defined(TCCR1A) && defined(WGM10) sbi(TCCR1A, WGM10); 1bc: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> 1c0: 81 60 ori r24, 0x01 ; 1 1c2: 80 93 80 00 sts 0x0080, r24 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> // set timer 2 prescale factor to 64 #if defined(TCCR2) && defined(CS22) sbi(TCCR2, CS22); #elif defined(TCCR2B) && defined(CS22) sbi(TCCR2B, CS22); 1c6: 80 91 b1 00 lds r24, 0x00B1 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1> 1ca: 84 60 ori r24, 0x04 ; 4 1cc: 80 93 b1 00 sts 0x00B1, r24 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1> // configure timer 2 for phase correct pwm (8-bit) #if defined(TCCR2) && defined(WGM20) sbi(TCCR2, WGM20); #elif defined(TCCR2A) && defined(WGM20) sbi(TCCR2A, WGM20); 1d0: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> 1d4: 81 60 ori r24, 0x01 ; 1 1d6: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> #endif #if defined(ADCSRA) // set a2d prescaler so we are inside the desired 50-200 KHz range. #if F_CPU >= 16000000 // 16 MHz / 128 = 125 KHz sbi(ADCSRA, ADPS2); 1da: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> 1de: 84 60 ori r24, 0x04 ; 4 1e0: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> sbi(ADCSRA, ADPS1); 1e4: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> 1e8: 82 60 ori r24, 0x02 ; 2 1ea: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> sbi(ADCSRA, ADPS0); 1ee: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> 1f2: 81 60 ori r24, 0x01 ; 1 1f4: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> cbi(ADCSRA, ADPS2); cbi(ADCSRA, ADPS1); sbi(ADCSRA, ADPS0); #endif // enable a2d conversions sbi(ADCSRA, ADEN); 1f8: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> 1fc: 80 68 ori r24, 0x80 ; 128 1fe: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> // here so they can be used as normal digital i/o; they will be // reconnected in Serial.begin() #if defined(UCSRB) UCSRB = 0; #elif defined(UCSR0B) UCSR0B = 0; 202: 10 92 c1 00 sts 0x00C1, r1 ; 0x8000c1 <__TEXT_REGION_LENGTH__+0x7e00c1> 206: e0 e0 ldi r30, 0x00 ; 0 208: f1 e0 ldi r31, 0x01 ; 1 20a: a8 e0 ldi r26, 0x08 ; 8 20c: b1 e0 ldi r27, 0x01 ; 1 20e: 88 e0 ldi r24, 0x08 ; 8 210: 91 e0 ldi r25, 0x01 ; 1 byte arr[8]; byte arr1[8] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}; void copyarr(byte *linkarr){ for(int i = 0; i < 8; i++){ arr[i] = linkarr[i]; 212: 21 91 ld r18, Z+ 214: 2d 93 st X+, r18 byte arr[8]; byte arr1[8] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}; void copyarr(byte *linkarr){ for(int i = 0; i < 8; i++){ 216: 8e 17 cp r24, r30 218: 9f 07 cpc r25, r31 21a: d9 f7 brne .-10 ; 0x212 <main+0x92> arr[i] = linkarr[i]; } if(arr[7] == 0x07) digitalWrite(0, 1); 21c: 80 91 0f 01 lds r24, 0x010F ; 0x80010f <__data_end+0x7> 220: 87 30 cpi r24, 0x07 ; 7 222: 09 f5 brne .+66 ; 0x266 <main+0xe6> } } void digitalWrite(uint8_t pin, uint8_t val) { uint8_t timer = digitalPinToTimer(pin); 224: ea e9 ldi r30, 0x9A ; 154 226: f0 e0 ldi r31, 0x00 ; 0 228: 84 91 lpm r24, Z uint8_t bit = digitalPinToBitMask(pin); 22a: e6 e8 ldi r30, 0x86 ; 134 22c: f0 e0 ldi r31, 0x00 ; 0 22e: 94 91 lpm r25, Z uint8_t port = digitalPinToPort(pin); 230: e2 e7 ldi r30, 0x72 ; 114 232: f0 e0 ldi r31, 0x00 ; 0 234: e4 91 lpm r30, Z volatile uint8_t *out; if (port == NOT_A_PIN) return; 236: ee 23 and r30, r30 238: b1 f0 breq .+44 ; 0x266 <main+0xe6> // If the pin that support PWM output, we need to turn it off // before doing a digital write. if (timer != NOT_ON_TIMER) turnOffPWM(timer); 23a: 88 23 and r24, r24 23c: 39 f0 breq .+14 ; 0x24c <main+0xcc> // //static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline)); //static inline void turnOffPWM(uint8_t timer) static void turnOffPWM(uint8_t timer) { switch (timer) 23e: 83 30 cpi r24, 0x03 ; 3 240: 19 f1 breq .+70 ; 0x288 <main+0x108> 242: c0 f4 brcc .+48 ; 0x274 <main+0xf4> 244: 81 30 cpi r24, 0x01 ; 1 246: 31 f1 breq .+76 ; 0x294 <main+0x114> 248: 82 30 cpi r24, 0x02 ; 2 24a: 41 f1 breq .+80 ; 0x29c <main+0x11c> // If the pin that support PWM output, we need to turn it off // before doing a digital write. if (timer != NOT_ON_TIMER) turnOffPWM(timer); out = portOutputRegister(port); 24c: f0 e0 ldi r31, 0x00 ; 0 24e: ee 0f add r30, r30 250: ff 1f adc r31, r31 252: e8 59 subi r30, 0x98 ; 152 254: ff 4f sbci r31, 0xFF ; 255 256: a5 91 lpm r26, Z+ 258: b4 91 lpm r27, Z uint8_t oldSREG = SREG; 25a: 8f b7 in r24, 0x3f ; 63 cli(); 25c: f8 94 cli if (val == LOW) { *out &= ~bit; } else { *out |= bit; 25e: ec 91 ld r30, X 260: 9e 2b or r25, r30 262: 9c 93 st X, r25 } SREG = oldSREG; 264: 8f bf out 0x3f, r24 ; 63 setup(); for (;;) { loop(); if (serialEventRun) serialEventRun(); 266: c0 e0 ldi r28, 0x00 ; 0 268: d0 e0 ldi r29, 0x00 ; 0 26a: 20 97 sbiw r28, 0x00 ; 0 26c: f1 f3 breq .-4 ; 0x26a <main+0xea> 26e: 0e 94 00 00 call 0 ; 0x0 <__vectors> 272: fb cf rjmp .-10 ; 0x26a <main+0xea> // //static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline)); //static inline void turnOffPWM(uint8_t timer) static void turnOffPWM(uint8_t timer) { switch (timer) 274: 87 30 cpi r24, 0x07 ; 7 276: a9 f0 breq .+42 ; 0x2a2 <main+0x122> 278: 88 30 cpi r24, 0x08 ; 8 27a: c9 f0 breq .+50 ; 0x2ae <main+0x12e> 27c: 84 30 cpi r24, 0x04 ; 4 27e: 31 f7 brne .-52 ; 0x24c <main+0xcc> { #if defined(TCCR1A) && defined(COM1A1) case TIMER1A: cbi(TCCR1A, COM1A1); break; #endif #if defined(TCCR1A) && defined(COM1B1) case TIMER1B: cbi(TCCR1A, COM1B1); break; 280: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> 284: 8f 7d andi r24, 0xDF ; 223 286: 03 c0 rjmp .+6 ; 0x28e <main+0x10e> static void turnOffPWM(uint8_t timer) { switch (timer) { #if defined(TCCR1A) && defined(COM1A1) case TIMER1A: cbi(TCCR1A, COM1A1); break; 288: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> 28c: 8f 77 andi r24, 0x7F ; 127 #endif #if defined(TCCR1A) && defined(COM1B1) case TIMER1B: cbi(TCCR1A, COM1B1); break; 28e: 80 93 80 00 sts 0x0080, r24 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> 292: dc cf rjmp .-72 ; 0x24c <main+0xcc> #if defined(TCCR2) && defined(COM21) case TIMER2: cbi(TCCR2, COM21); break; #endif #if defined(TCCR0A) && defined(COM0A1) case TIMER0A: cbi(TCCR0A, COM0A1); break; 294: 84 b5 in r24, 0x24 ; 36 296: 8f 77 andi r24, 0x7F ; 127 #endif #if defined(TCCR0A) && defined(COM0B1) case TIMER0B: cbi(TCCR0A, COM0B1); break; 298: 84 bd out 0x24, r24 ; 36 29a: d8 cf rjmp .-80 ; 0x24c <main+0xcc> 29c: 84 b5 in r24, 0x24 ; 36 29e: 8f 7d andi r24, 0xDF ; 223 2a0: fb cf rjmp .-10 ; 0x298 <main+0x118> #endif #if defined(TCCR2A) && defined(COM2A1) case TIMER2A: cbi(TCCR2A, COM2A1); break; 2a2: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> 2a6: 8f 77 andi r24, 0x7F ; 127 #endif #if defined(TCCR2A) && defined(COM2B1) case TIMER2B: cbi(TCCR2A, COM2B1); break; 2a8: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> 2ac: cf cf rjmp .-98 ; 0x24c <main+0xcc> 2ae: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> 2b2: 8f 7d andi r24, 0xDF ; 223 2b4: f9 cf rjmp .-14 ; 0x2a8 <main+0x128> 000002b6 <_exit>: 2b6: f8 94 cli 000002b8 <__stop_program>: 2b8: ff cf rjmp .-2 ; 0x2b8 <__stop_program>В первом случае, без функции копирования, в ОЗУ программно тупо копируются константы (в массив arr).
Скетч использует 692 байт (2%) памяти устройства. Всего доступно 32256 байт.
Глобальные переменные используют 17 байт
(резервирование ОЗУ под один массив)
Во втором случае, с функцией, данные arr1 прописанные в флэше, сначала копируются в ОЗУ, далее из ОЗУ arr1 копируются в область ОЗУ для arr.
Скетч использует 706 байт (2%) памяти устройства. Всего доступно 32256 байт.
Глобальные переменные используют 25 байт
(резервирование ОЗУ под два массива)
Любопытно..
И в случае неиспользования в теле скетча, оптимизируются в 0 компилятором, и код и данные.
Скетч использует 444 байт (1%) памяти устройства. Всего доступно 32256 байт.
Глобальные переменные используют 9 байт
аналогичен вот этому ?
Да, нет же! Я ж Вам ещё в #12 писал, что они принципиально разные!
Мне казалось по последним постам, что Вы это понимаете. Или просто троллите нас?
только вопрос почему с ней же второй код на 8 байт короче остается не разгаданным
А по вашему для вызова функции не надо никаких команд?