RadioTest_ATMEL_RECEIVER.elf: file format elf32-avr Sections: Idx Name Size VMA LMA File off Algn 0 .data 00000148 00800200 0000119a 0000122e 2**0 CONTENTS, ALLOC, LOAD, DATA 1 .text 0000119a 00000000 00000000 00000094 2**1 CONTENTS, ALLOC, LOAD, READONLY, CODE 2 .bss 0000009f 00800348 00800348 00001376 2**0 ALLOC 3 .debug_aranges 00000080 00000000 00000000 00001376 2**0 CONTENTS, READONLY, DEBUGGING 4 .debug_pubnames 0000083d 00000000 00000000 000013f6 2**0 CONTENTS, READONLY, DEBUGGING 5 .debug_info 00001f2e 00000000 00000000 00001c33 2**0 CONTENTS, READONLY, DEBUGGING 6 .debug_abbrev 00000665 00000000 00000000 00003b61 2**0 CONTENTS, READONLY, DEBUGGING 7 .debug_line 0000152a 00000000 00000000 000041c6 2**0 CONTENTS, READONLY, DEBUGGING 8 .debug_frame 00000520 00000000 00000000 000056f0 2**2 CONTENTS, READONLY, DEBUGGING 9 .debug_str 00000b78 00000000 00000000 00005c10 2**0 CONTENTS, READONLY, DEBUGGING 10 .debug_loc 0000123f 00000000 00000000 00006788 2**0 CONTENTS, READONLY, DEBUGGING 11 .debug_ranges 00000060 00000000 00000000 000079c7 2**0 CONTENTS, READONLY, DEBUGGING Disassembly of section .text: 00000000 <__vectors>: 0: 0c 94 90 00 jmp 0x120 ; 0x120 <__ctors_end> 4: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 8: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> c: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 10: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 14: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 18: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 1c: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 20: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 24: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 28: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 2c: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 30: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 34: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 38: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 3c: 0c 94 70 01 jmp 0x2e0 ; 0x2e0 <__vector_15> 40: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 44: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 48: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 4c: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 50: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 54: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 58: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 5c: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 60: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 64: 0c 94 69 05 jmp 0xad2 ; 0xad2 <__vector_25> 68: 0c 94 99 05 jmp 0xb32 ; 0xb32 <__vector_26> 6c: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 70: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 74: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 78: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 7c: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 80: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 84: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 88: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 8c: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 90: 0c 94 39 06 jmp 0xc72 ; 0xc72 <__vector_36> 94: 0c 94 69 06 jmp 0xcd2 ; 0xcd2 <__vector_37> 98: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 9c: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> a0: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> a4: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> a8: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> ac: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> b0: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> b4: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> b8: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> bc: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> c0: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> c4: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> c8: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> cc: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> d0: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> d4: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> d8: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> dc: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> e0: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> e4: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> e8: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> ec: 0c 94 7f 01 jmp 0x2fe ; 0x2fe <__vector_59> f0: 0c 94 89 01 jmp 0x312 ; 0x312 <__vector_60> f4: 0c 94 a5 01 jmp 0x34a ; 0x34a <__vector_61> f8: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> fc: 0c 94 6a 03 jmp 0x6d4 ; 0x6d4 <__vector_63> 100: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 104: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 108: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 10c: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 110: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 114: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 118: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 11c: 0c 94 af 00 jmp 0x15e ; 0x15e <__bad_interrupt> 00000120 <__ctors_end>: 120: 11 24 eor r1, r1 122: 1f be out 0x3f, r1 ; 63 124: cf ef ldi r28, 0xFF ; 255 126: d1 e4 ldi r29, 0x41 ; 65 128: de bf out 0x3e, r29 ; 62 12a: cd bf out 0x3d, r28 ; 61 0000012c <__do_copy_data>: 12c: 13 e0 ldi r17, 0x03 ; 3 12e: a0 e0 ldi r26, 0x00 ; 0 130: b2 e0 ldi r27, 0x02 ; 2 132: ea e9 ldi r30, 0x9A ; 154 134: f1 e1 ldi r31, 0x11 ; 17 136: 00 e0 ldi r16, 0x00 ; 0 138: 0b bf out 0x3b, r16 ; 59 13a: 02 c0 rjmp .+4 ; 0x140 <__do_copy_data+0x14> 13c: 07 90 elpm r0, Z+ 13e: 0d 92 st X+, r0 140: a8 34 cpi r26, 0x48 ; 72 142: b1 07 cpc r27, r17 144: d9 f7 brne .-10 ; 0x13c <__do_copy_data+0x10> 00000146 <__do_clear_bss>: 146: 13 e0 ldi r17, 0x03 ; 3 148: a8 e4 ldi r26, 0x48 ; 72 14a: b3 e0 ldi r27, 0x03 ; 3 14c: 01 c0 rjmp .+2 ; 0x150 <.do_clear_bss_start> 0000014e <.do_clear_bss_loop>: 14e: 1d 92 st X+, r1 00000150 <.do_clear_bss_start>: 150: a7 3e cpi r26, 0xE7 ; 231 152: b1 07 cpc r27, r17 154: e1 f7 brne .-8 ; 0x14e <.do_clear_bss_loop> 156: 0e 94 c1 02 call 0x582 ; 0x582
15a: 0c 94 cb 08 jmp 0x1196 ; 0x1196 <_exit> 0000015e <__bad_interrupt>: 15e: 0c 94 00 00 jmp 0 ; 0x0 <__vectors> 00000162 : * \brief Main function for low power and energy saving tests * \ingroup TestFunctions */ void transceiver_reset(void) { // @TODO include code here; } 162: 08 95 ret 00000164 : void transceiver_set_channel(uint8_t new_channel){ PHY_CC_CCA = new_channel; 164: 80 93 48 01 sts 0x0148, r24 } 168: 08 95 ret 0000016a : void transceiver_set_tx_power(uint8_t new_power){ PHY_TX_PWR &= ~((1 << TX_PWR3)|(1 << TX_PWR2)|(1 << TX_PWR1)|(1 << TX_PWR0)); 16a: e5 e4 ldi r30, 0x45 ; 69 16c: f1 e0 ldi r31, 0x01 ; 1 16e: 90 81 ld r25, Z 170: 90 7f andi r25, 0xF0 ; 240 172: 90 83 st Z, r25 PHY_TX_PWR |= ( new_power & ((1 << TX_PWR3)|(1 << TX_PWR2)|(1 << TX_PWR1)|(1 << TX_PWR0))); 174: 90 81 ld r25, Z 176: 8f 70 andi r24, 0x0F ; 15 178: 89 2b or r24, r25 17a: 80 83 st Z, r24 } 17c: 08 95 ret 0000017e : void transceiver_set_addr_short(uint16_t short_addr) { SHORT_ADDR_0 = (uint8_t) short_addr; 17e: 80 93 60 01 sts 0x0160, r24 SHORT_ADDR_1 = (uint8_t) (short_addr >> 8); 182: 90 93 61 01 sts 0x0161, r25 } 186: 08 95 ret 00000188 : void transceiver_set_addr_ieee(uint64_t ieee_address) { 188: 9f 92 push r9 18a: af 92 push r10 18c: bf 92 push r11 18e: cf 92 push r12 190: df 92 push r13 192: ef 92 push r14 194: ff 92 push r15 196: 0f 93 push r16 198: 1f 93 push r17 19a: cf 93 push r28 19c: df 93 push r29 19e: 92 2e mov r9, r18 1a0: a3 2e mov r10, r19 1a2: b4 2e mov r11, r20 1a4: c5 2e mov r12, r21 1a6: d6 2e mov r13, r22 1a8: e7 2e mov r14, r23 1aa: f8 2e mov r15, r24 1ac: 19 2f mov r17, r25 1ae: c0 e0 ldi r28, 0x00 ; 0 1b0: d0 e0 ldi r29, 0x00 ; 0 for (int var = 0; var < 8; ++var) { *(&IEEE_ADDR_0 + var) = (uint8_t) (ieee_address >> var); 1b2: 29 2d mov r18, r9 1b4: 3a 2d mov r19, r10 1b6: 4b 2d mov r20, r11 1b8: 5c 2d mov r21, r12 1ba: 6d 2d mov r22, r13 1bc: 7e 2d mov r23, r14 1be: 8f 2d mov r24, r15 1c0: 91 2f mov r25, r17 1c2: 0c 2f mov r16, r28 1c4: 0e 94 07 08 call 0x100e ; 0x100e <__lshrdi3> void transceiver_set_addr_short(uint16_t short_addr) { SHORT_ADDR_0 = (uint8_t) short_addr; SHORT_ADDR_1 = (uint8_t) (short_addr >> 8); } void transceiver_set_addr_ieee(uint64_t ieee_address) { 1c8: cc 59 subi r28, 0x9C ; 156 1ca: de 4f sbci r29, 0xFE ; 254 for (int var = 0; var < 8; ++var) { *(&IEEE_ADDR_0 + var) = (uint8_t) (ieee_address >> var); 1cc: 28 83 st Y, r18 SHORT_ADDR_0 = (uint8_t) short_addr; SHORT_ADDR_1 = (uint8_t) (short_addr >> 8); } void transceiver_set_addr_ieee(uint64_t ieee_address) { for (int var = 0; var < 8; ++var) { 1ce: c3 56 subi r28, 0x63 ; 99 1d0: d1 40 sbci r29, 0x01 ; 1 1d2: c8 30 cpi r28, 0x08 ; 8 1d4: d1 05 cpc r29, r1 1d6: 69 f7 brne .-38 ; 0x1b2 *(&IEEE_ADDR_0 + var) = (uint8_t) (ieee_address >> var); } } 1d8: df 91 pop r29 1da: cf 91 pop r28 1dc: 1f 91 pop r17 1de: 0f 91 pop r16 1e0: ff 90 pop r15 1e2: ef 90 pop r14 1e4: df 90 pop r13 1e6: cf 90 pop r12 1e8: bf 90 pop r11 1ea: af 90 pop r10 1ec: 9f 90 pop r9 1ee: 08 95 ret 000001f0 : void transceiver_set_panID(uint16_t panID) { PAN_ID_0 = (uint8_t) panID; 1f0: 80 93 62 01 sts 0x0162, r24 PAN_ID_1 = (uint8_t) (panID >> 8); 1f4: 90 93 63 01 sts 0x0163, r25 } 1f8: 08 95 ret 000001fa : int transceiver_start_pll(void) { uint8_t state = (uint8_t) (TRX_STATUS & ((1 << TRX_STATUS4) | (1 << TRX_STATUS3) | (1 << TRX_STATUS2) | (1 << TRX_STATUS1) | (1 << TRX_STATUS0))); 1fa: 80 91 41 01 lds r24, 0x0141 1fe: 8f 71 andi r24, 0x1F ; 31 // ensure that transceiver is in a valid state // and no state transition is in progress if ((state != STATE_TRANSITION_IN_PROGRESS) && ((state == RX_ON) || (state 200: 8f 31 cpi r24, 0x1F ; 31 202: 91 f0 breq .+36 ; 0x228 204: 86 30 cpi r24, 0x06 ; 6 206: 11 f0 breq .+4 ; 0x20c 208: 88 30 cpi r24, 0x08 ; 8 20a: 71 f4 brne .+28 ; 0x228 == TRX_OFF))) { TRX_STATE = PLL_ON; 20c: 89 e0 ldi r24, 0x09 ; 9 20e: 80 93 42 01 sts 0x0142, r24 milliseconds can be achieved. */ void _delay_loop_2(uint16_t __count) { __asm__ volatile ( 212: 80 e2 ldi r24, 0x20 ; 32 214: 93 e0 ldi r25, 0x03 ; 3 216: 01 97 sbiw r24, 0x01 ; 1 218: f1 f7 brne .-4 ; 0x216 _delay_us(200); // typ. value is 110 us, but depends on external cap @ AVDD if ((TRX_STATUS & ((1 << TRX_STATUS4) | (1 << TRX_STATUS3) | (1 21a: 80 91 41 01 lds r24, 0x0141 21e: 20 e0 ldi r18, 0x00 ; 0 220: 30 e0 ldi r19, 0x00 ; 0 222: 8f 71 andi r24, 0x1F ; 31 224: 89 30 cpi r24, 0x09 ; 9 226: 11 f0 breq .+4 ; 0x22c 228: 21 e0 ldi r18, 0x01 ; 1 22a: 30 e0 ldi r19, 0x00 ; 0 return 0; } else return 1; } else return 1; } 22c: c9 01 movw r24, r18 22e: 08 95 ret 00000230 : char* transceiver_PowerRegValTodBmString(uint8_t regval){ switch (regval) { 230: 87 30 cpi r24, 0x07 ; 7 232: b9 f1 breq .+110 ; 0x2a2 234: 88 30 cpi r24, 0x08 ; 8 236: 70 f4 brcc .+28 ; 0x254 238: 83 30 cpi r24, 0x03 ; 3 23a: 39 f1 breq .+78 ; 0x28a 23c: 84 30 cpi r24, 0x04 ; 4 23e: 28 f4 brcc .+10 ; 0x24a 240: 81 30 cpi r24, 0x01 ; 1 242: d1 f0 breq .+52 ; 0x278 244: 82 30 cpi r24, 0x02 ; 2 246: f0 f4 brcc .+60 ; 0x284 248: 1a c0 rjmp .+52 ; 0x27e 24a: 85 30 cpi r24, 0x05 ; 5 24c: 21 f1 breq .+72 ; 0x296 24e: 86 30 cpi r24, 0x06 ; 6 250: 28 f5 brcc .+74 ; 0x29c 252: 1e c0 rjmp .+60 ; 0x290 254: 8b 30 cpi r24, 0x0B ; 11 256: 89 f1 breq .+98 ; 0x2ba 258: 8c 30 cpi r24, 0x0C ; 12 25a: 28 f4 brcc .+10 ; 0x266 25c: 89 30 cpi r24, 0x09 ; 9 25e: 39 f1 breq .+78 ; 0x2ae 260: 8a 30 cpi r24, 0x0A ; 10 262: 40 f5 brcc .+80 ; 0x2b4 264: 21 c0 rjmp .+66 ; 0x2a8 266: 8d 30 cpi r24, 0x0D ; 13 268: 71 f1 breq .+92 ; 0x2c6 26a: 8d 30 cpi r24, 0x0D ; 13 26c: 48 f1 brcs .+82 ; 0x2c0 26e: 8e 30 cpi r24, 0x0E ; 14 270: 69 f1 breq .+90 ; 0x2cc 272: 8f 30 cpi r24, 0x0F ; 15 274: 89 f5 brne .+98 ; 0x2d8 276: 2d c0 rjmp .+90 ; 0x2d2 278: 20 e0 ldi r18, 0x00 ; 0 27a: 32 e0 ldi r19, 0x02 ; 2 27c: 2f c0 rjmp .+94 ; 0x2dc 27e: 24 e0 ldi r18, 0x04 ; 4 280: 32 e0 ldi r19, 0x02 ; 2 282: 2c c0 rjmp .+88 ; 0x2dc 284: 28 e0 ldi r18, 0x08 ; 8 286: 32 e0 ldi r19, 0x02 ; 2 288: 29 c0 rjmp .+82 ; 0x2dc case 0 : return "3.0"; case 1 : return "2.8"; case 2 : return "2.3"; 28a: 2c e0 ldi r18, 0x0C ; 12 28c: 32 e0 ldi r19, 0x02 ; 2 28e: 26 c0 rjmp .+76 ; 0x2dc case 3 : return "1.8"; 290: 20 e1 ldi r18, 0x10 ; 16 292: 32 e0 ldi r19, 0x02 ; 2 294: 23 c0 rjmp .+70 ; 0x2dc case 4 : return "1.3"; 296: 24 e1 ldi r18, 0x14 ; 20 298: 32 e0 ldi r19, 0x02 ; 2 29a: 20 c0 rjmp .+64 ; 0x2dc case 5 : return "0.7"; 29c: 28 e1 ldi r18, 0x18 ; 24 29e: 32 e0 ldi r19, 0x02 ; 2 2a0: 1d c0 rjmp .+58 ; 0x2dc case 6 : return "0.0"; 2a2: 2c e1 ldi r18, 0x1C ; 28 2a4: 32 e0 ldi r19, 0x02 ; 2 2a6: 1a c0 rjmp .+52 ; 0x2dc case 7 : return "-1"; 2a8: 2f e1 ldi r18, 0x1F ; 31 2aa: 32 e0 ldi r19, 0x02 ; 2 2ac: 17 c0 rjmp .+46 ; 0x2dc case 8 : return "-2"; 2ae: 22 e2 ldi r18, 0x22 ; 34 2b0: 32 e0 ldi r19, 0x02 ; 2 2b2: 14 c0 rjmp .+40 ; 0x2dc case 9 : return "-3"; 2b4: 25 e2 ldi r18, 0x25 ; 37 2b6: 32 e0 ldi r19, 0x02 ; 2 2b8: 11 c0 rjmp .+34 ; 0x2dc case 10 : return "-4"; 2ba: 28 e2 ldi r18, 0x28 ; 40 2bc: 32 e0 ldi r19, 0x02 ; 2 2be: 0e c0 rjmp .+28 ; 0x2dc case 11 : return "-5"; 2c0: 2b e2 ldi r18, 0x2B ; 43 2c2: 32 e0 ldi r19, 0x02 ; 2 2c4: 0b c0 rjmp .+22 ; 0x2dc case 12 : return "-7"; 2c6: 2e e2 ldi r18, 0x2E ; 46 2c8: 32 e0 ldi r19, 0x02 ; 2 2ca: 08 c0 rjmp .+16 ; 0x2dc case 13 : return "-9"; 2cc: 21 e3 ldi r18, 0x31 ; 49 2ce: 32 e0 ldi r19, 0x02 ; 2 2d0: 05 c0 rjmp .+10 ; 0x2dc case 14 : return "-12"; 2d2: 25 e3 ldi r18, 0x35 ; 53 2d4: 32 e0 ldi r19, 0x02 ; 2 2d6: 02 c0 rjmp .+4 ; 0x2dc case 15 : return "-17"; 2d8: 29 e3 ldi r18, 0x39 ; 57 2da: 32 e0 ldi r19, 0x02 ; 2 default: return "#ERROR"; } } 2dc: c9 01 movw r24, r18 2de: 08 95 ret 000002e0 <__vector_15>: * On execution it should toggle the middle LED (LED3). * The execution interval is (1024*256)/32,768 = 8 s (external crystal is clock source). */ ISR( TIMER2_OVF_vect ) { 2e0: 1f 92 push r1 2e2: 0f 92 push r0 2e4: 0f b6 in r0, 0x3f ; 63 2e6: 0f 92 push r0 2e8: 11 24 eor r1, r1 2ea: 8f 93 push r24 flag = 1; 2ec: 81 e0 ldi r24, 0x01 ; 1 2ee: 80 93 d4 03 sts 0x03D4, r24 } 2f2: 8f 91 pop r24 2f4: 0f 90 pop r0 2f6: 0f be out 0x3f, r0 ; 63 2f8: 0f 90 pop r0 2fa: 1f 90 pop r1 2fc: 18 95 reti 000002fe <__vector_59>: xmit_done_flag = 1; } #ifdef RECEIVER ISR (TRX24_RX_START_vect) { 2fe: 1f 92 push r1 300: 0f 92 push r0 302: 0f b6 in r0, 0x3f ; 63 304: 0f 92 push r0 306: 11 24 eor r1, r1 // toggle_bit(LED_PORT, LED3); } 308: 0f 90 pop r0 30a: 0f be out 0x3f, r0 ; 63 30c: 0f 90 pop r0 30e: 1f 90 pop r1 310: 18 95 reti 00000312 <__vector_60>: ISR (TRX24_RX_END_vect) { 312: 1f 92 push r1 314: 0f 92 push r0 316: 0f b6 in r0, 0x3f ; 63 318: 0f 92 push r0 31a: 0b b6 in r0, 0x3b ; 59 31c: 0f 92 push r0 31e: 11 24 eor r1, r1 320: 8f 93 push r24 322: ef 93 push r30 324: ff 93 push r31 // protect the received frame TRX_CTRL_2 |= (1 << RX_SAFE_MODE); 326: ec e4 ldi r30, 0x4C ; 76 328: f1 e0 ldi r31, 0x01 ; 1 32a: 80 81 ld r24, Z 32c: 80 68 ori r24, 0x80 ; 128 32e: 80 83 st Z, r24 recv_flag = TRUE; 330: 81 e0 ldi r24, 0x01 ; 1 332: 80 93 d3 03 sts 0x03D3, r24 } 336: ff 91 pop r31 338: ef 91 pop r30 33a: 8f 91 pop r24 33c: 0f 90 pop r0 33e: 0b be out 0x3b, r0 ; 59 340: 0f 90 pop r0 342: 0f be out 0x3f, r0 ; 63 344: 0f 90 pop r0 346: 1f 90 pop r1 348: 18 95 reti 0000034a <__vector_61>: #endif ISR(TRX24_CCA_ED_DONE_vect) { 34a: 1f 92 push r1 34c: 0f 92 push r0 34e: 0f b6 in r0, 0x3f ; 63 350: 0f 92 push r0 352: 11 24 eor r1, r1 354: 8f 93 push r24 cca_flag = 1; 356: 81 e0 ldi r24, 0x01 ; 1 358: 80 93 d5 03 sts 0x03D5, r24 if (bit_is_set(TRX_STATUS, CCA_STATUS)) { 35c: 80 91 41 01 lds r24, 0x0141 360: 86 ff sbrs r24, 6 362: 02 c0 rjmp .+4 ; 0x368 <__vector_61+0x1e> set_bit(LED_PORT, LED4); 364: 74 9a sbi 0x0e, 4 ; 14 366: 01 c0 rjmp .+2 ; 0x36a <__vector_61+0x20> } else { clear_bit(LED_PORT, LED4); 368: 74 98 cbi 0x0e, 4 ; 14 } } 36a: 8f 91 pop r24 36c: 0f 90 pop r0 36e: 0f be out 0x3f, r0 ; 63 370: 0f 90 pop r0 372: 1f 90 pop r1 374: 18 95 reti 00000376 : // average_lqi = 0; // uart_writeNewline(); } } void doReceiverEval(void) { 376: bf 92 push r11 378: cf 92 push r12 37a: df 92 push r13 37c: ef 92 push r14 37e: ff 92 push r15 380: 0f 93 push r16 382: 1f 93 push r17 384: cf 93 push r28 386: df 93 push r29 * 3.) * */ uint8_t len, seq, ack, appByte, lqi, crc, channel, power; len = TST_RX_LENGTH; 388: 00 91 7b 01 lds r16, 0x017B seq = getSequenceNumber(frame_start_rx); 38c: 80 91 38 03 lds r24, 0x0338 390: 90 91 39 03 lds r25, 0x0339 394: 0e 94 38 05 call 0xa70 ; 0xa70 398: e8 2e mov r14, r24 ack = getACKRequestFlag(frame_start_rx); 39a: 80 91 38 03 lds r24, 0x0338 39e: 90 91 39 03 lds r25, 0x0339 3a2: 0e 94 1d 05 call 0xa3a ; 0xa3a 3a6: b8 2e mov r11, r24 appByte = getAppCommandByte(frame_start_rx); 3a8: 80 91 38 03 lds r24, 0x0338 3ac: 90 91 39 03 lds r25, 0x0339 3b0: 0e 94 63 05 call 0xac6 ; 0xac6 3b4: 18 2f mov r17, r24 lqi = getLQI(&TRXFBEND); 3b6: 8f ef ldi r24, 0xFF ; 255 3b8: 91 e0 ldi r25, 0x01 ; 1 3ba: 0e 94 66 05 call 0xacc ; 0xacc 3be: f8 2e mov r15, r24 crc = (PHY_RSSI >> 7); 3c0: c0 90 46 01 lds r12, 0x0146 channel = PHY_CC_CCA; 3c4: d0 90 48 01 lds r13, 0x0148 power = (PHY_TX_PWR & ((1 << TX_PWR3)|(1 << TX_PWR2)|(1 << TX_PWR1)|(1 << TX_PWR0))); 3c8: 80 91 45 01 lds r24, 0x0145 TRX_CTRL_2 &= ~(1 << RX_SAFE_MODE); 3cc: 80 91 4c 01 lds r24, 0x014C 3d0: 8f 77 andi r24, 0x7F ; 127 3d2: 80 93 4c 01 sts 0x014C, r24 test_vec[0][(uint8_t)num_rcvd_packets] = lqi; 3d6: e0 91 d8 03 lds r30, 0x03D8 3da: f0 e0 ldi r31, 0x00 ; 0 3dc: ee 5d subi r30, 0xDE ; 222 3de: fc 4f sbci r31, 0xFC ; 252 3e0: f0 82 st Z, r15 switch (appByte) { 3e2: 11 23 and r17, r17 3e4: 21 f0 breq .+8 ; 0x3ee 3e6: 1c 3c cpi r17, 0xCC ; 204 3e8: 09 f0 breq .+2 ; 0x3ec 3ea: 41 c0 rjmp .+130 ; 0x46e 3ec: 19 c0 rjmp .+50 ; 0x420 case TEST_FRAME: if (len == MIN_PACKET_LENGTH){ 3ee: 04 31 cpi r16, 0x14 ; 20 3f0: 39 f4 brne .+14 ; 0x400 uart_writeString(" 20! "); 3f2: 80 e4 ldi r24, 0x40 ; 64 3f4: 92 e0 ldi r25, 0x02 ; 2 3f6: 0e 94 14 06 call 0xc28 ; 0xc28 // test_vec[0][num_rcvd_packets] = lqi; lqi_20 = lqi; 3fa: f0 92 e1 03 sts 0x03E1, r15 3fe: 06 c0 rjmp .+12 ; 0x40c } else { uart_writeString(" 127! "); 400: 86 e4 ldi r24, 0x46 ; 70 402: 92 e0 ldi r25, 0x02 ; 2 404: 0e 94 14 06 call 0xc28 ; 0xc28 // test_vec[1][num_rcvd_packets] = lqi; lqi_127 = lqi; 408: f0 92 db 03 sts 0x03DB, r15 } num_rcvd_packets++; 40c: 80 91 d8 03 lds r24, 0x03D8 410: 90 91 d9 03 lds r25, 0x03D9 414: 01 96 adiw r24, 0x01 ; 1 416: 90 93 d9 03 sts 0x03D9, r25 41a: 80 93 d8 03 sts 0x03D8, r24 41e: 2b c0 rjmp .+86 ; 0x476 break; 420: c0 e0 ldi r28, 0x00 ; 0 422: d0 e0 ldi r29, 0x00 ; 0 case CHANNEL_CHANGE: channel += CHANNEL_STEP; for (int var = 0; var < NUMBER_OF_FRAMES_PER_BLOCK; var++) { // uart_writeNumberDec(test_vec[0][var]); uart_writeNumberDec(lqi_20); 424: 60 91 e1 03 lds r22, 0x03E1 428: 70 e0 ldi r23, 0x00 ; 0 42a: 80 e0 ldi r24, 0x00 ; 0 42c: 90 e0 ldi r25, 0x00 ; 0 42e: 0e 94 af 07 call 0xf5e ; 0xf5e break; case CHANNEL_CHANGE: channel += CHANNEL_STEP; for (int var = 0; var < NUMBER_OF_FRAMES_PER_BLOCK; var++) { 432: 21 96 adiw r28, 0x01 ; 1 434: ca 30 cpi r28, 0x0A ; 10 436: d1 05 cpc r29, r1 438: a9 f7 brne .-22 ; 0x424 // uart_writeNumberDec(test_vec[0][var]); uart_writeNumberDec(lqi_20); } uart_writeNewline(); 43a: 0e 94 21 06 call 0xc42 ; 0xc42 43e: c0 e0 ldi r28, 0x00 ; 0 440: d0 e0 ldi r29, 0x00 ; 0 for (int var = 0; var < NUMBER_OF_FRAMES_PER_BLOCK; var++) { // uart_writeNumberDec(test_vec[1][var]); uart_writeNumberDec(lqi_127); 442: 60 91 db 03 lds r22, 0x03DB 446: 70 e0 ldi r23, 0x00 ; 0 448: 80 e0 ldi r24, 0x00 ; 0 44a: 90 e0 ldi r25, 0x00 ; 0 44c: 0e 94 af 07 call 0xf5e ; 0xf5e for (int var = 0; var < NUMBER_OF_FRAMES_PER_BLOCK; var++) { // uart_writeNumberDec(test_vec[0][var]); uart_writeNumberDec(lqi_20); } uart_writeNewline(); for (int var = 0; var < NUMBER_OF_FRAMES_PER_BLOCK; var++) { 450: 21 96 adiw r28, 0x01 ; 1 452: ca 30 cpi r28, 0x0A ; 10 454: d1 05 cpc r29, r1 456: a9 f7 brne .-22 ; 0x442 } num_rcvd_packets++; break; case CHANNEL_CHANGE: channel += CHANNEL_STEP; 458: d3 94 inc r13 uart_writeNewline(); for (int var = 0; var < NUMBER_OF_FRAMES_PER_BLOCK; var++) { // uart_writeNumberDec(test_vec[1][var]); uart_writeNumberDec(lqi_127); } uart_writeNewline(); 45a: 0e 94 21 06 call 0xc42 ; 0xc42 45e: 80 ea ldi r24, 0xA0 ; 160 460: 9f e0 ldi r25, 0x0F ; 15 462: 01 97 sbiw r24, 0x01 ; 1 464: f1 f7 brne .-4 ; 0x462 _delay_ms(1); write_channel_flag = TRUE; 466: 81 e0 ldi r24, 0x01 ; 1 468: 80 93 dc 03 sts 0x03DC, r24 46c: 04 c0 rjmp .+8 ; 0x476 break; default: uart_writeString("DEFAULT"); 46e: 8d e4 ldi r24, 0x4D ; 77 470: 92 e0 ldi r25, 0x02 ; 2 472: 0e 94 14 06 call 0xc28 ; 0xc28 break; } if (num_rcvd_packets > 99) uart_writeString(""); 476: 80 91 d8 03 lds r24, 0x03D8 47a: 90 91 d9 03 lds r25, 0x03D9 47e: 84 36 cpi r24, 0x64 ; 100 480: 91 05 cpc r25, r1 482: 18 f0 brcs .+6 ; 0x48a 484: 85 e5 ldi r24, 0x55 ; 85 486: 92 e0 ldi r25, 0x02 ; 2 488: 07 c0 rjmp .+14 ; 0x498 else { if ((num_rcvd_packets > 9))uart_writeString(" "); 48a: 0a 97 sbiw r24, 0x0a ; 10 48c: 18 f0 brcs .+6 ; 0x494 48e: 86 e5 ldi r24, 0x56 ; 86 490: 92 e0 ldi r25, 0x02 ; 2 492: 02 c0 rjmp .+4 ; 0x498 else uart_writeString(" "); 494: 88 e5 ldi r24, 0x58 ; 88 496: 92 e0 ldi r25, 0x02 ; 2 498: 0e 94 14 06 call 0xc28 ; 0xc28 } // uart_writeString("Received Packet # "); uart_writeNumberDec(num_rcvd_packets); 49c: 60 91 d8 03 lds r22, 0x03D8 4a0: 70 91 d9 03 lds r23, 0x03D9 4a4: 80 e0 ldi r24, 0x00 ; 0 4a6: 90 e0 ldi r25, 0x00 ; 0 4a8: 0e 94 af 07 call 0xf5e ; 0xf5e if (len > 99) uart_writeString(" |"); 4ac: 04 36 cpi r16, 0x64 ; 100 4ae: 18 f0 brcs .+6 ; 0x4b6 4b0: 8b e5 ldi r24, 0x5B ; 91 4b2: 92 e0 ldi r25, 0x02 ; 2 4b4: 02 c0 rjmp .+4 ; 0x4ba else uart_writeString(" | "); 4b6: 8e e5 ldi r24, 0x5E ; 94 4b8: 92 e0 ldi r25, 0x02 ; 2 4ba: 0e 94 14 06 call 0xc28 ; 0xc28 uart_writeNumberDec(len); 4be: 60 2f mov r22, r16 4c0: 70 e0 ldi r23, 0x00 ; 0 4c2: 80 e0 ldi r24, 0x00 ; 0 4c4: 90 e0 ldi r25, 0x00 ; 0 4c6: 0e 94 af 07 call 0xf5e ; 0xf5e // uart_writeString(" Octets"); uart_writeString(" | "); 4ca: 8e e5 ldi r24, 0x5E ; 94 4cc: 92 e0 ldi r25, 0x02 ; 2 4ce: 0e 94 14 06 call 0xc28 ; 0xc28 uart_writeNumberHex(ack); 4d2: 6b 2d mov r22, r11 4d4: 70 e0 ldi r23, 0x00 ; 0 4d6: 80 e0 ldi r24, 0x00 ; 0 4d8: 90 e0 ldi r25, 0x00 ; 0 4da: 0e 94 57 07 call 0xeae ; 0xeae if (seq > 99) uart_writeString(" | "); 4de: 83 e6 ldi r24, 0x63 ; 99 4e0: 8e 15 cp r24, r14 4e2: 18 f4 brcc .+6 ; 0x4ea 4e4: 8e e5 ldi r24, 0x5E ; 94 4e6: 92 e0 ldi r25, 0x02 ; 2 4e8: 08 c0 rjmp .+16 ; 0x4fa else { if ((seq > 9))uart_writeString(" | "); 4ea: 89 e0 ldi r24, 0x09 ; 9 4ec: 8e 15 cp r24, r14 4ee: 18 f4 brcc .+6 ; 0x4f6 4f0: 82 e6 ldi r24, 0x62 ; 98 4f2: 92 e0 ldi r25, 0x02 ; 2 4f4: 02 c0 rjmp .+4 ; 0x4fa else uart_writeString(" | "); 4f6: 87 e6 ldi r24, 0x67 ; 103 4f8: 92 e0 ldi r25, 0x02 ; 2 4fa: 0e 94 14 06 call 0xc28 ; 0xc28 } // uart_writeString(" | Seq : "); uart_writeNumberDec(seq); 4fe: 6e 2d mov r22, r14 500: 70 e0 ldi r23, 0x00 ; 0 502: 80 e0 ldi r24, 0x00 ; 0 504: 90 e0 ldi r25, 0x00 ; 0 506: 0e 94 af 07 call 0xf5e ; 0xf5e if (appByte > 0x0F) uart_writeString(" | "); 50a: 10 31 cpi r17, 0x10 ; 16 50c: 18 f0 brcs .+6 ; 0x514 50e: 8e e5 ldi r24, 0x5E ; 94 510: 92 e0 ldi r25, 0x02 ; 2 512: 02 c0 rjmp .+4 ; 0x518 else uart_writeString(" | "); 514: 82 e6 ldi r24, 0x62 ; 98 516: 92 e0 ldi r25, 0x02 ; 2 518: 0e 94 14 06 call 0xc28 ; 0xc28 // uart_writeString(" | AppByte : "); uart_writeNumberHex(appByte); 51c: 61 2f mov r22, r17 51e: 70 e0 ldi r23, 0x00 ; 0 520: 80 e0 ldi r24, 0x00 ; 0 522: 90 e0 ldi r25, 0x00 ; 0 524: 0e 94 57 07 call 0xeae ; 0xeae uart_writeString(" | "); 528: 8e e5 ldi r24, 0x5E ; 94 52a: 92 e0 ldi r25, 0x02 ; 2 52c: 0e 94 14 06 call 0xc28 ; 0xc28 // uart_writeString(transceiver_PowerRegValTodBmString(power)); // uart_writeString(" | "); uart_writeNumberDec(channel); 530: 6d 2d mov r22, r13 532: 70 e0 ldi r23, 0x00 ; 0 534: 80 e0 ldi r24, 0x00 ; 0 536: 90 e0 ldi r25, 0x00 ; 0 538: 0e 94 af 07 call 0xf5e ; 0xf5e uart_writeString(" | "); 53c: 8e e5 ldi r24, 0x5E ; 94 53e: 92 e0 ldi r25, 0x02 ; 2 540: 0e 94 14 06 call 0xc28 ; 0xc28 uart_writeNumberDec(lqi); 544: 6f 2d mov r22, r15 546: 70 e0 ldi r23, 0x00 ; 0 548: 80 e0 ldi r24, 0x00 ; 0 54a: 90 e0 ldi r25, 0x00 ; 0 54c: 0e 94 af 07 call 0xf5e ; 0xf5e uart_writeString(" | "); 550: 8e e5 ldi r24, 0x5E ; 94 552: 92 e0 ldi r25, 0x02 ; 2 554: 0e 94 14 06 call 0xc28 ; 0xc28 uart_writeNumberDec(crc); 558: cc 1c adc r12, r12 55a: cc 24 eor r12, r12 55c: cc 1c adc r12, r12 55e: 6c 2d mov r22, r12 560: 70 e0 ldi r23, 0x00 ; 0 562: 80 e0 ldi r24, 0x00 ; 0 564: 90 e0 ldi r25, 0x00 ; 0 566: 0e 94 af 07 call 0xf5e ; 0xf5e uart_writeNewline(); 56a: 0e 94 21 06 call 0xc42 ; 0xc42 } 56e: df 91 pop r29 570: cf 91 pop r28 572: 1f 91 pop r17 574: 0f 91 pop r16 576: ff 90 pop r15 578: ef 90 pop r14 57a: df 90 pop r13 57c: cf 90 pop r12 57e: bf 90 pop r11 580: 08 95 ret 00000582
: #else #error "No matching device role defined for setup!" #endif int main(void) { cli(); 582: f8 94 cli CLKPR = (1 << CLKPCE); // allow change of pre-scale bits 584: 80 e8 ldi r24, 0x80 ; 128 586: 80 93 61 00 sts 0x0061, r24 CLKPR = ((1 << CLKPS3) | (1 << CLKPS2) | (1 << CLKPS1) | (1 << CLKPS0)); // disable internal pre-scaling (not FLASH/EEPROM writes not allowed) 58a: 8f e0 ldi r24, 0x0F ; 15 58c: 80 93 61 00 sts 0x0061, r24 LED_DDR = ALL_LEDS; // enable LED pins as output 590: 8c e1 ldi r24, 0x1C ; 28 592: 8d b9 out 0x0d, r24 ; 13 LED_PORT &= ~ALL_LEDS; // turn on LEDs (active low) 594: 8e b1 in r24, 0x0e ; 14 596: 83 7e andi r24, 0xE3 ; 227 598: 8e b9 out 0x0e, r24 ; 14 for (loopvar = 0; loopvar != 3; loopvar++) { 59a: 10 92 de 03 sts 0x03DE, r1 59e: 10 92 dd 03 sts 0x03DD, r1 5a2: 20 e9 ldi r18, 0x90 ; 144 5a4: 31 e0 ldi r19, 0x01 ; 1 _delay_ms(250); LED_PORT ^= ALL_LEDS; // toggle LEDs 5a6: 4c e1 ldi r20, 0x1C ; 28 5a8: 13 c0 rjmp .+38 ; 0x5d0 CLKPR = (1 << CLKPCE); // allow change of pre-scale bits CLKPR = ((1 << CLKPS3) | (1 << CLKPS2) | (1 << CLKPS1) | (1 << CLKPS0)); // disable internal pre-scaling (not FLASH/EEPROM writes not allowed) LED_DDR = ALL_LEDS; // enable LED pins as output LED_PORT &= ~ALL_LEDS; // turn on LEDs (active low) for (loopvar = 0; loopvar != 3; loopvar++) { 5aa: 84 ec ldi r24, 0xC4 ; 196 5ac: 99 e0 ldi r25, 0x09 ; 9 5ae: f9 01 movw r30, r18 5b0: 31 97 sbiw r30, 0x01 ; 1 5b2: f1 f7 brne .-4 ; 0x5b0 __ticks = (uint16_t) (__ms * 10.0); while(__ticks) { // wait 1/10 ms _delay_loop_2(((F_CPU) / 4e3) / 10); __ticks --; 5b4: 01 97 sbiw r24, 0x01 ; 1 __ticks = 1; else if (__tmp > 65535) { // __ticks = requested delay in 1/10 ms __ticks = (uint16_t) (__ms * 10.0); while(__ticks) 5b6: d9 f7 brne .-10 ; 0x5ae _delay_ms(250); LED_PORT ^= ALL_LEDS; // toggle LEDs 5b8: 8e b1 in r24, 0x0e ; 14 5ba: 84 27 eor r24, r20 5bc: 8e b9 out 0x0e, r24 ; 14 CLKPR = (1 << CLKPCE); // allow change of pre-scale bits CLKPR = ((1 << CLKPS3) | (1 << CLKPS2) | (1 << CLKPS1) | (1 << CLKPS0)); // disable internal pre-scaling (not FLASH/EEPROM writes not allowed) LED_DDR = ALL_LEDS; // enable LED pins as output LED_PORT &= ~ALL_LEDS; // turn on LEDs (active low) for (loopvar = 0; loopvar != 3; loopvar++) { 5be: 80 91 dd 03 lds r24, 0x03DD 5c2: 90 91 de 03 lds r25, 0x03DE 5c6: 01 96 adiw r24, 0x01 ; 1 5c8: 90 93 de 03 sts 0x03DE, r25 5cc: 80 93 dd 03 sts 0x03DD, r24 5d0: 80 91 dd 03 lds r24, 0x03DD 5d4: 90 91 de 03 lds r25, 0x03DE 5d8: 03 97 sbiw r24, 0x03 ; 3 5da: 39 f7 brne .-50 ; 0x5aa 5dc: 84 ec ldi r24, 0xC4 ; 196 5de: 99 e0 ldi r25, 0x09 ; 9 5e0: 20 e9 ldi r18, 0x90 ; 144 5e2: 31 e0 ldi r19, 0x01 ; 1 5e4: f9 01 movw r30, r18 5e6: 31 97 sbiw r30, 0x01 ; 1 5e8: f1 f7 brne .-4 ; 0x5e6 { // wait 1/10 ms _delay_loop_2(((F_CPU) / 4e3) / 10); __ticks --; 5ea: 01 97 sbiw r24, 0x01 ; 1 __ticks = 1; else if (__tmp > 65535) { // __ticks = requested delay in 1/10 ms __ticks = (uint16_t) (__ms * 10.0); while(__ticks) 5ec: d9 f7 brne .-10 ; 0x5e4 _delay_ms(250); LED_PORT ^= ALL_LEDS; // toggle LEDs } _delay_ms(250); LED_PORT &= ~((1 << LED2) | (1 << LED4)); 5ee: 8e b1 in r24, 0x0e ; 14 5f0: 8b 7e andi r24, 0xEB ; 235 5f2: 8e b9 out 0x0e, r24 ; 14 5f4: 88 e8 ldi r24, 0x88 ; 136 5f6: 93 e1 ldi r25, 0x13 ; 19 5f8: 20 e9 ldi r18, 0x90 ; 144 5fa: 31 e0 ldi r19, 0x01 ; 1 5fc: f9 01 movw r30, r18 5fe: 31 97 sbiw r30, 0x01 ; 1 600: f1 f7 brne .-4 ; 0x5fe { // wait 1/10 ms _delay_loop_2(((F_CPU) / 4e3) / 10); __ticks --; 602: 01 97 sbiw r24, 0x01 ; 1 __ticks = 1; else if (__tmp > 65535) { // __ticks = requested delay in 1/10 ms __ticks = (uint16_t) (__ms * 10.0); while(__ticks) 604: d9 f7 brne .-10 ; 0x5fc _delay_ms(500); LED_PORT |= ALL_LEDS; // Turn off LEDs for measurement 606: 8e b1 in r24, 0x0e ; 14 608: 8c 61 ori r24, 0x1C ; 28 60a: 8e b9 out 0x0e, r24 ; 14 clear_bit(PRR0, PRTIM2); // enable Timer2 60c: 80 91 64 00 lds r24, 0x0064 610: 8f 7b andi r24, 0xBF ; 191 612: 80 93 64 00 sts 0x0064, r24 ASSR &= ~((1 << EXCLKAMR) | (1 << EXCLK)); // set clock source to external crystal AS2=1, EXCLK=0, EXCKLAMR=0 616: 80 91 b6 00 lds r24, 0x00B6 61a: 8f 73 andi r24, 0x3F ; 63 61c: 80 93 b6 00 sts 0x00B6, r24 set_bit(ASSR, AS2); // alternate clock source 620: 80 91 b6 00 lds r24, 0x00B6 624: 80 62 ori r24, 0x20 ; 32 626: 80 93 b6 00 sts 0x00B6, r24 TCCR2B |= ((1 << CS22) | (1 << CS21) | (1 << CS20)); // set pre-scaler to longest possible (f_clk/1024) 62a: 80 91 b1 00 lds r24, 0x00B1 62e: 87 60 ori r24, 0x07 ; 7 630: 80 93 b1 00 sts 0x00B1, r24 // set_bit(TIMSK2, TOIE2); // enable overflow interrupt set_bit(DDRE, DDE6); // set PE0 to output -> time measurement 634: 6e 9a sbi 0x0d, 6 ; 13 clear_bit(PRR0, PRUSART0); // enable USART0 636: 80 91 64 00 lds r24, 0x0064 63a: 8d 7f andi r24, 0xFD ; 253 63c: 80 93 64 00 sts 0x0064, r24 /* Enable SRAM Data Retention */ DRTRAM0 = _BV(ENDRT); 640: 80 e1 ldi r24, 0x10 ; 16 642: 80 93 35 01 sts 0x0135, r24 DRTRAM1 = _BV(ENDRT); 646: 80 93 34 01 sts 0x0134, r24 DRTRAM2 = _BV(ENDRT); 64a: 80 93 33 01 sts 0x0133, r24 DRTRAM3 = _BV(ENDRT); 64e: 80 93 32 01 sts 0x0132, r24 uart_init( UART_BAUD_SELECT(BAUD,F_CPU) ); 652: 8c e0 ldi r24, 0x0C ; 12 654: 90 e0 ldi r25, 0x00 ; 0 656: 0e 94 c7 05 call 0xb8e ; 0xb8e sei(); 65a: 78 94 sei LED_PORT = 0xFF; // turn off LEDs 65c: 8f ef ldi r24, 0xFF ; 255 65e: 8e b9 out 0x0e, r24 ; 14 set_bit(PORTE, 6); // set PE6 high to test with oscilloscope 660: 76 9a sbi 0x0e, 6 ; 14 * additionally we can do the following: * we turn the node into a sniffer, by disabling the address filters (promiscous mode) * we then enable an LED in case of a received frame (TRX24_RX_START * if the CRC/FCS is invalid we switch on another LED */ clear_bit(PRR1, PRTRX24); 662: 80 91 65 00 lds r24, 0x0065 666: 8f 7b andi r24, 0xBF ; 191 668: 80 93 65 00 sts 0x0065, r24 // RX_SYN |= ((1< 690: 80 e2 ldi r24, 0x20 ; 32 692: 93 e0 ldi r25, 0x03 ; 3 694: 01 97 sbiw r24, 0x01 ; 1 696: f1 f7 brne .-4 ; 0x694 _delay_us(200); TRX_STATE = CMD_RX_ON; } else TRX_STATE = CMD_RX_ON; 698: 86 e0 ldi r24, 0x06 ; 6 69a: 80 93 42 01 sts 0x0142, r24 is_xmitter = FALSE; 69e: 10 92 da 03 sts 0x03DA, r1 transceiver_set_channel(curr_channel); } #endif #ifdef RECEIVER if(recv_flag == TRUE){ 6a2: 80 91 d3 03 lds r24, 0x03D3 6a6: 81 30 cpi r24, 0x01 ; 1 6a8: e1 f7 brne .-8 ; 0x6a2 recv_flag = FALSE; 6aa: 10 92 d3 03 sts 0x03D3, r1 doReceiverEval(); 6ae: 0e 94 bb 01 call 0x376 ; 0x376 6b2: f7 cf rjmp .-18 ; 0x6a2 000006b4 : // } } } #elif defined RECEIVER void printChannelResult(void) { 6b4: 1f 93 push r17 6b6: 10 e0 ldi r17, 0x00 ; 0 // uart_writeNumberDec(lqi_temp); // } for (int power_c = MAX_TX_POWER; power_c < (MIN_TX_POWER + 1); (power_c += TX_POWER_STEP)) { /* print LQI for both payload sizes for every power setting */ uart_writeString(transceiver_PowerRegValTodBmString(power_c)); 6b8: 81 2f mov r24, r17 6ba: 0e 94 18 01 call 0x230 ; 0x230 6be: 0e 94 14 06 call 0xc28 ; 0xc28 uart_writeLine("dBm"); 6c2: 8d e6 ldi r24, 0x6D ; 109 6c4: 92 e0 ldi r25, 0x02 ; 2 6c6: 0e 94 26 06 call 0xc4c ; 0xc4c 6ca: 1d 5f subi r17, 0xFD ; 253 // for (int temp = 0; temp < NUMBER_OF_FRAMES_PER_BLOCK; temp++) { // uint8_t lqi_temp = channel_matrix[0][1][temp]; // uart_writeNumberDec(lqi_temp); // } for (int power_c = MAX_TX_POWER; power_c < (MIN_TX_POWER + 1); (power_c += TX_POWER_STEP)) { 6cc: 12 31 cpi r17, 0x12 ; 18 6ce: a1 f7 brne .-24 ; 0x6b8 // uart_writeString("Average LQI : "); // uart_writeNumberDec(average_lqi/NUMBER_OF_FRAMES_PER_BLOCK); // average_lqi = 0; // uart_writeNewline(); } } 6d0: 1f 91 pop r17 6d2: 08 95 ret 000006d4 <__vector_63>: { flag = 1; } ISR( TRX24_TX_END_vect) { 6d4: 1f 92 push r1 6d6: 0f 92 push r0 6d8: 0f b6 in r0, 0x3f ; 63 6da: 0f 92 push r0 6dc: 0b b6 in r0, 0x3b ; 59 6de: 0f 92 push r0 6e0: 11 24 eor r1, r1 6e2: 1f 93 push r17 6e4: 2f 93 push r18 6e6: 3f 93 push r19 6e8: 4f 93 push r20 6ea: 5f 93 push r21 6ec: 6f 93 push r22 6ee: 7f 93 push r23 6f0: 8f 93 push r24 6f2: 9f 93 push r25 6f4: af 93 push r26 6f6: bf 93 push r27 6f8: ef 93 push r30 6fa: ff 93 push r31 uint8_t xmit_status; // we need to check the transmission status and set the transmission flag // we could also ensure that we are in the correct state PLL_ON/TX_ARET_ON xmit_status = ((TRX_STATE >> 5) & 0x07); 6fc: 10 91 42 01 lds r17, 0x0142 /* test wether we are in an extended operating mode */ if ((TRX_STATUS & ((1 << TRX_STATUS4) | (1 << TRX_STATUS3) | (1 700: 80 91 41 01 lds r24, 0x0141 704: 8f 71 andi r24, 0x1F ; 31 706: 89 30 cpi r24, 0x09 ; 9 708: c1 f1 breq .+112 ; 0x77a <__vector_63+0xa6> << TRX_STATUS2) | (1 << TRX_STATUS1) | (1 << TRX_STATUS0))) != PLL_ON) { uart_writeLine("TX_ARET_MODE ON!"); 70a: 81 e7 ldi r24, 0x71 ; 113 70c: 92 e0 ldi r25, 0x02 ; 2 70e: 0e 94 26 06 call 0xc4c ; 0xc4c uart_writeString("TRAC_STATUS = "); 712: 82 e8 ldi r24, 0x82 ; 130 714: 92 e0 ldi r25, 0x02 ; 2 716: 0e 94 14 06 call 0xc28 ; 0xc28 switch (xmit_status) { 71a: 81 2f mov r24, r17 71c: 82 95 swap r24 71e: 86 95 lsr r24 720: 87 70 andi r24, 0x07 ; 7 722: 83 30 cpi r24, 0x03 ; 3 724: a9 f0 breq .+42 ; 0x750 <__vector_63+0x7c> 726: 84 30 cpi r24, 0x04 ; 4 728: 28 f4 brcc .+10 ; 0x734 <__vector_63+0x60> 72a: 88 23 and r24, r24 72c: 41 f0 breq .+16 ; 0x73e <__vector_63+0x6a> 72e: 81 30 cpi r24, 0x01 ; 1 730: 21 f5 brne .+72 ; 0x77a <__vector_63+0xa6> 732: 0b c0 rjmp .+22 ; 0x74a <__vector_63+0x76> 734: 85 30 cpi r24, 0x05 ; 5 736: 71 f0 breq .+28 ; 0x754 <__vector_63+0x80> 738: 87 30 cpi r24, 0x07 ; 7 73a: f9 f4 brne .+62 ; 0x77a <__vector_63+0xa6> 73c: 18 c0 rjmp .+48 ; 0x76e <__vector_63+0x9a> case ((uint8_t) TRAC_SUCCESS): xmit_done_flag = 1; 73e: 81 e0 ldi r24, 0x01 ; 1 740: 80 93 d6 03 sts 0x03D6, r24 write_channel_flag = 1; 744: 80 93 dc 03 sts 0x03DC, r24 748: 18 c0 rjmp .+48 ; 0x77a <__vector_63+0xa6> break; case ((uint8_t) TRAC_SUCCESS_DATA_PENDING): xmit_done_flag = 1; 74a: 80 93 d6 03 sts 0x03D6, r24 74e: 15 c0 rjmp .+42 ; 0x77a <__vector_63+0xa6> case ((uint8_t) TRAC_SUCCESS_WAIT_FOR_ACK): break; // do something here case ((uint8_t) TRAC_CHANNEL_ACCESS_FAILURE): LED_PORT = ((1 << LED2) | (1 << LED4)); 750: 84 e1 ldi r24, 0x14 ; 20 752: 12 c0 rjmp .+36 ; 0x778 <__vector_63+0xa4> break; // do something here case ((uint8_t) TRAC_NO_ACK): uart_writeLine( 754: 81 e9 ldi r24, 0x91 ; 145 756: 92 e0 ldi r25, 0x02 ; 2 758: 0e 94 26 06 call 0xc4c ; 0xc4c " ----> DID NOT RECEIVE ACK FOR CHANNEL CHANGE REQUEST <----"); uart_writeLine( 75c: 8d ec ldi r24, 0xCD ; 205 75e: 92 e0 ldi r25, 0x02 ; 2 760: 0e 94 26 06 call 0xc4c ; 0xc4c " ----> ABORTING TEST <----"); uart_writeString("TRAC_STATUS = "); 764: 82 e8 ldi r24, 0x82 ; 130 766: 92 e0 ldi r25, 0x02 ; 2 768: 0e 94 14 06 call 0xc28 ; 0xc28 76c: 06 c0 rjmp .+12 ; 0x77a <__vector_63+0xa6> break; // we could signal this to the app layer case ((uint8_t) TRAC_INVALID): uart_writeLine("THIS SHOULD BE PRINTED"); 76e: 89 e0 ldi r24, 0x09 ; 9 770: 93 e0 ldi r25, 0x03 ; 3 772: 0e 94 26 06 call 0xc4c ; 0xc4c LED_PORT = ((1 << LED2) | (1 << LED3) | (1 << LED4)); 776: 8c e1 ldi r24, 0x1C ; 28 778: 8e b9 out 0x0e, r24 ; 14 default: // xmit_done_flag = 1; break; } } xmit_done_flag = 1; 77a: 81 e0 ldi r24, 0x01 ; 1 77c: 80 93 d6 03 sts 0x03D6, r24 } 780: ff 91 pop r31 782: ef 91 pop r30 784: bf 91 pop r27 786: af 91 pop r26 788: 9f 91 pop r25 78a: 8f 91 pop r24 78c: 7f 91 pop r23 78e: 6f 91 pop r22 790: 5f 91 pop r21 792: 4f 91 pop r20 794: 3f 91 pop r19 796: 2f 91 pop r18 798: 1f 91 pop r17 79a: 0f 90 pop r0 79c: 0b be out 0x3b, r0 ; 59 79e: 0f 90 pop r0 7a0: 0f be out 0x3f, r0 ; 63 7a2: 0f 90 pop r0 7a4: 1f 90 pop r1 7a6: 18 95 reti 000007a8 : #include "simpleProtocol.h" #include "testSetup.h" uint8_t invert_bit_order(uint8_t org){ org=((org>>1)&0x55)|((org<<1)&0xaa); 7a8: 98 2f mov r25, r24 7aa: 99 0f add r25, r25 7ac: 9a 7a andi r25, 0xAA ; 170 7ae: 86 95 lsr r24 7b0: 85 75 andi r24, 0x55 ; 85 7b2: 98 2b or r25, r24 org=((org>>2)&0x33)|((org<<2)&0xcc); 7b4: 89 2f mov r24, r25 7b6: 88 0f add r24, r24 7b8: 88 0f add r24, r24 7ba: 8c 7c andi r24, 0xCC ; 204 7bc: 96 95 lsr r25 7be: 96 95 lsr r25 7c0: 93 73 andi r25, 0x33 ; 51 7c2: 89 2b or r24, r25 7c4: 98 2f mov r25, r24 7c6: 92 95 swap r25 7c8: 9f 70 andi r25, 0x0F ; 15 7ca: 82 95 swap r24 7cc: 80 7f andi r24, 0xF0 ; 240 return (org>>4)|(org<<4); } 7ce: 89 2b or r24, r25 7d0: 08 95 ret 000007d2 : void writeFrameControlField (volatile uint8_t* startOfFrame, uint16_t frameControlFieldValue){ 7d2: fc 01 movw r30, r24 *(startOfFrame) = (uint8_t)(frameControlFieldValue >> 8); 7d4: 70 83 st Z, r23 *(startOfFrame+1) = (uint8_t)(frameControlFieldValue); 7d6: 61 83 std Z+1, r22 ; 0x01 } 7d8: 08 95 ret 000007da : void writeTestFrame(volatile uint8_t* startOfFrame, uint8_t frame_number, uint8_t length){ 7da: fc 01 movw r30, r24 setFrameLength(startOfFrame, (uint8_t)(LENGTH_MAC_HDR + length)); 7dc: 42 5f subi r20, 0xF2 ; 242 setAppCommandByte(startOfFrame, CHANNEL_CHANGE); setRandomPayload(startOfFrame, length); } void setFrameLength(volatile uint8_t* startOfFrame, uint8_t length){ *(startOfFrame-1) = length; 7de: 42 93 st -Z, r20 7e0: 4e 50 subi r20, 0x0E ; 14 7e2: 31 96 adiw r30, 0x01 ; 1 org=((org>>2)&0x33)|((org<<2)&0xcc); return (org>>4)|(org<<4); } void writeFrameControlField (volatile uint8_t* startOfFrame, uint16_t frameControlFieldValue){ *(startOfFrame) = (uint8_t)(frameControlFieldValue >> 8); 7e4: 81 e0 ldi r24, 0x01 ; 1 7e6: 80 83 st Z, r24 *(startOfFrame+1) = (uint8_t)(frameControlFieldValue); 7e8: 11 82 std Z+1, r1 ; 0x01 /* SET operations*/ void setFrameType(volatile uint8_t* startOfFrame, uint8_t frameType){ uint8_t frameControlFieldL; frameControlFieldL = *(startOfFrame); 7ea: 80 81 ld r24, Z frameControlFieldL &= ~(((uint16_t)FRAMETYPE_MASK) >> 8); 7ec: 88 7f andi r24, 0xF8 ; 248 frameControlFieldL |= (frameType)&(((uint16_t)FRAMETYPE_MASK) >> 8); 7ee: 81 60 ori r24, 0x01 ; 1 *(startOfFrame) = frameControlFieldL; 7f0: 80 83 st Z, r24 void setDestinationAddressingMode(volatile uint8_t* startOfFrame, uint8_t addrMode){ uint8_t frameControlFieldL; frameControlFieldL = *(startOfFrame+1); 7f2: 81 81 ldd r24, Z+1 ; 0x01 frameControlFieldL &= ~(DEST_ADDR_MODE_MASK); frameControlFieldL |= (addrMode << 2)&(DEST_ADDR_MODE_MASK); 7f4: 83 7f andi r24, 0xF3 ; 243 7f6: 88 60 ori r24, 0x08 ; 8 *(startOfFrame+1) = (uint8_t) frameControlFieldL; 7f8: 81 83 std Z+1, r24 ; 0x01 } void setFrameVersion(volatile uint8_t* startOfFrame, uint8_t version){ uint8_t frameControlFieldL; frameControlFieldL = *(startOfFrame+1); 7fa: 81 81 ldd r24, Z+1 ; 0x01 frameControlFieldL &= ~(FRAME_VERSION_MASK); 7fc: 8f 7c andi r24, 0xCF ; 207 frameControlFieldL |= (version << 4)&(FRAME_VERSION_MASK); *(startOfFrame+1) = (uint8_t) frameControlFieldL; 7fe: 81 83 std Z+1, r24 ; 0x01 } void setSourceAddressingMode(volatile uint8_t* startOfFrame, uint8_t addrMode){ uint8_t frameControlFieldL; frameControlFieldL = *(startOfFrame+1); 800: 81 81 ldd r24, Z+1 ; 0x01 frameControlFieldL &= ~(SRC_ADDR_MODE_MASK); frameControlFieldL |= (addrMode << 6)&(SRC_ADDR_MODE_MASK); 802: 8f 73 andi r24, 0x3F ; 63 804: 80 68 ori r24, 0x80 ; 128 *(startOfFrame+1) = (uint8_t) frameControlFieldL; 806: 81 83 std Z+1, r24 ; 0x01 } void setSequenceNumber(volatile uint8_t* startOfFrame, uint8_t seqNumber){ *(startOfFrame + 2) = seqNumber; 808: 62 83 std Z+2, r22 ; 0x02 } void setDestinationPANID(volatile uint8_t* startOfFrame, uint16_t destPAN){ *(startOfFrame + 3) = (uint8_t) destPAN; 80a: 9e ef ldi r25, 0xFE ; 254 80c: 93 83 std Z+3, r25 ; 0x03 *(startOfFrame + 4) = (uint8_t) (destPAN >> 8); 80e: 2a ec ldi r18, 0xCA ; 202 810: 24 83 std Z+4, r18 ; 0x04 } void setDestinationAddress(volatile uint8_t* startOfFrame, uint16_t destAddr){ *(startOfFrame + 5) = (uint8_t) destAddr; 812: 95 83 std Z+5, r25 ; 0x05 *(startOfFrame + 6) = (uint8_t) (destAddr >> 8); 814: 8f ea ldi r24, 0xAF ; 175 816: 86 83 std Z+6, r24 ; 0x06 } void setSourcePANID(volatile uint8_t* startOfFrame, uint16_t srcPAN){ *(startOfFrame + 7) = (uint8_t) srcPAN; 818: 97 83 std Z+7, r25 ; 0x07 *(startOfFrame + 8) = (uint8_t) (srcPAN >> 8); 81a: 20 87 std Z+8, r18 ; 0x08 } void setSourceAddress(volatile uint8_t* startOfFrame, uint16_t srcAddr){ *(startOfFrame + 9) = (uint8_t) srcAddr; 81c: 91 87 std Z+9, r25 ; 0x09 *(startOfFrame + 10) = (uint8_t) (srcAddr >> 8); 81e: 92 87 std Z+10, r25 ; 0x0a } void setAppCommandByte(volatile uint8_t* startOfFrame, uint8_t command){ *(startOfFrame + 11) = command; 820: 13 86 std Z+11, r1 ; 0x0b 822: 3c 96 adiw r30, 0x0c ; 12 824: 80 e0 ldi r24, 0x00 ; 0 826: 90 e0 ldi r25, 0x00 ; 0 } void setRandomPayload(volatile uint8_t* startOfFrame, uint8_t length){ for (int var = 0; var < length; ++var) { 828: 50 e0 ldi r21, 0x00 ; 0 *(startOfFrame + 12 + var) = 0xFF; 82a: 2f ef ldi r18, 0xFF ; 255 82c: 02 c0 rjmp .+4 ; 0x832 82e: 21 93 st Z+, r18 void setAppCommandByte(volatile uint8_t* startOfFrame, uint8_t command){ *(startOfFrame + 11) = command; } void setRandomPayload(volatile uint8_t* startOfFrame, uint8_t length){ for (int var = 0; var < length; ++var) { 830: 01 96 adiw r24, 0x01 ; 1 832: 84 17 cp r24, r20 834: 95 07 cpc r25, r21 836: dc f3 brlt .-10 ; 0x82e setDestinationAddress(startOfFrame, TEST_ADDR_SHORT_RX); setSourcePANID(startOfFrame, TEST_PANID); setSourceAddress(startOfFrame, TEST_ADDR_SHORT_TX); setAppCommandByte(startOfFrame, TEST_FRAME); setRandomPayload(startOfFrame, length); } 838: 08 95 ret 0000083a : setAppCommandByte(startOfFrame, CHANNEL_CHANGE); setRandomPayload(startOfFrame, length); } void setFrameLength(volatile uint8_t* startOfFrame, uint8_t length){ *(startOfFrame-1) = length; 83a: fc 01 movw r30, r24 83c: 31 97 sbiw r30, 0x01 ; 1 83e: 60 83 st Z, r22 } 840: 08 95 ret 00000842 : /* SET operations*/ void setFrameType(volatile uint8_t* startOfFrame, uint8_t frameType){ 842: fc 01 movw r30, r24 uint8_t frameControlFieldL; frameControlFieldL = *(startOfFrame); 844: 80 81 ld r24, Z frameControlFieldL &= ~(((uint16_t)FRAMETYPE_MASK) >> 8); 846: 88 7f andi r24, 0xF8 ; 248 frameControlFieldL |= (frameType)&(((uint16_t)FRAMETYPE_MASK) >> 8); 848: 67 70 andi r22, 0x07 ; 7 84a: 86 2b or r24, r22 *(startOfFrame) = frameControlFieldL; 84c: 80 83 st Z, r24 } 84e: 08 95 ret 00000850 : void setSecurityEnabledFlag(volatile uint8_t* startOfFrame){ 850: fc 01 movw r30, r24 uint16_t frameControlField; frameControlField = (((uint16_t) *(startOfFrame)) << 8); 852: 80 81 ld r24, Z 854: 38 2f mov r19, r24 856: 20 e0 ldi r18, 0x00 ; 0 frameControlField |= (uint16_t) *(startOfFrame + 1); 858: 81 81 ldd r24, Z+1 ; 0x01 85a: 90 e0 ldi r25, 0x00 ; 0 85c: 82 2b or r24, r18 85e: 93 2b or r25, r19 frameControlField |= SECURITY_ENABLED_MASK; 860: 98 60 ori r25, 0x08 ; 8 *(startOfFrame) = (uint8_t) (frameControlField >> 8); 862: 90 83 st Z, r25 *(startOfFrame + 1) = (uint8_t) frameControlField; 864: 81 83 std Z+1, r24 ; 0x01 } 866: 08 95 ret 00000868 : void setFramePendingFlag(volatile uint8_t* startOfFrame){ 868: fc 01 movw r30, r24 uint16_t frameControlField; frameControlField = (((uint16_t)*(startOfFrame)) << 8); 86a: 80 81 ld r24, Z 86c: 38 2f mov r19, r24 86e: 20 e0 ldi r18, 0x00 ; 0 frameControlField |= (uint16_t) *(startOfFrame+1); 870: 81 81 ldd r24, Z+1 ; 0x01 872: 90 e0 ldi r25, 0x00 ; 0 874: 82 2b or r24, r18 876: 93 2b or r25, r19 frameControlField |= FRAME_PENDING_MASK; 878: 90 61 ori r25, 0x10 ; 16 *(startOfFrame) = (uint8_t)(frameControlField >> 8); 87a: 90 83 st Z, r25 *(startOfFrame+1) = (uint8_t) frameControlField; 87c: 81 83 std Z+1, r24 ; 0x01 } 87e: 08 95 ret 00000880 : void setACKRequestFlag(volatile uint8_t* startOfFrame){ 880: fc 01 movw r30, r24 uint16_t frameControlField; frameControlField = (((uint16_t) *(startOfFrame)) << 8); 882: 80 81 ld r24, Z 884: 38 2f mov r19, r24 886: 20 e0 ldi r18, 0x00 ; 0 frameControlField |= (uint16_t) *(startOfFrame + 1); 888: 81 81 ldd r24, Z+1 ; 0x01 88a: 90 e0 ldi r25, 0x00 ; 0 88c: 82 2b or r24, r18 88e: 93 2b or r25, r19 frameControlField |= ACK_REQUEST_MASK; 890: 90 62 ori r25, 0x20 ; 32 *(startOfFrame) = (uint8_t) (frameControlField >> 8); 892: 90 83 st Z, r25 *(startOfFrame + 1) = (uint8_t) frameControlField; 894: 81 83 std Z+1, r24 ; 0x01 } 896: 08 95 ret 00000898 : setSourceAddress(startOfFrame, TEST_ADDR_SHORT_TX); setAppCommandByte(startOfFrame, TEST_FRAME); setRandomPayload(startOfFrame, length); } void writeChannelChangeFrame(volatile uint8_t* startOfFrame, uint8_t frame_number, uint8_t length){ 898: ef 92 push r14 89a: ff 92 push r15 89c: 0f 93 push r16 89e: 1f 93 push r17 8a0: 8c 01 movw r16, r24 8a2: e6 2e mov r14, r22 8a4: f4 2e mov r15, r20 setFrameLength(startOfFrame, (uint8_t)(LENGTH_MAC_HDR + length)); 8a6: 8e e0 ldi r24, 0x0E ; 14 8a8: f8 0e add r15, r24 setAppCommandByte(startOfFrame, CHANNEL_CHANGE); setRandomPayload(startOfFrame, length); } void setFrameLength(volatile uint8_t* startOfFrame, uint8_t length){ *(startOfFrame-1) = length; 8aa: f8 01 movw r30, r16 8ac: f2 92 st -Z, r15 8ae: 8f 01 movw r16, r30 8b0: f2 ef ldi r31, 0xF2 ; 242 8b2: ff 0e add r15, r31 8b4: 0f 5f subi r16, 0xFF ; 255 8b6: 1f 4f sbci r17, 0xFF ; 255 org=((org>>2)&0x33)|((org<<2)&0xcc); return (org>>4)|(org<<4); } void writeFrameControlField (volatile uint8_t* startOfFrame, uint16_t frameControlFieldValue){ *(startOfFrame) = (uint8_t)(frameControlFieldValue >> 8); 8b8: 81 e0 ldi r24, 0x01 ; 1 8ba: f8 01 movw r30, r16 8bc: 80 83 st Z, r24 *(startOfFrame+1) = (uint8_t)(frameControlFieldValue); 8be: 11 82 std Z+1, r1 ; 0x01 /* SET operations*/ void setFrameType(volatile uint8_t* startOfFrame, uint8_t frameType){ uint8_t frameControlFieldL; frameControlFieldL = *(startOfFrame); 8c0: 80 81 ld r24, Z frameControlFieldL &= ~(((uint16_t)FRAMETYPE_MASK) >> 8); 8c2: 88 7f andi r24, 0xF8 ; 248 frameControlFieldL |= (frameType)&(((uint16_t)FRAMETYPE_MASK) >> 8); 8c4: 81 60 ori r24, 0x01 ; 1 *(startOfFrame) = frameControlFieldL; 8c6: 80 83 st Z, r24 void writeChannelChangeFrame(volatile uint8_t* startOfFrame, uint8_t frame_number, uint8_t length){ setFrameLength(startOfFrame, (uint8_t)(LENGTH_MAC_HDR + length)); writeFrameControlField(startOfFrame, STANDARD_FRAME_CONTROL_FIELD); setFrameType(startOfFrame,DATA_FRAME); setACKRequestFlag(startOfFrame); 8c8: c8 01 movw r24, r16 8ca: 0e 94 40 04 call 0x880 ; 0x880 void setDestinationAddressingMode(volatile uint8_t* startOfFrame, uint8_t addrMode){ uint8_t frameControlFieldL; frameControlFieldL = *(startOfFrame+1); 8ce: f8 01 movw r30, r16 8d0: 81 81 ldd r24, Z+1 ; 0x01 frameControlFieldL &= ~(DEST_ADDR_MODE_MASK); frameControlFieldL |= (addrMode << 2)&(DEST_ADDR_MODE_MASK); 8d2: 83 7f andi r24, 0xF3 ; 243 8d4: 88 60 ori r24, 0x08 ; 8 *(startOfFrame+1) = (uint8_t) frameControlFieldL; 8d6: 81 83 std Z+1, r24 ; 0x01 } void setFrameVersion(volatile uint8_t* startOfFrame, uint8_t version){ uint8_t frameControlFieldL; frameControlFieldL = *(startOfFrame+1); 8d8: 81 81 ldd r24, Z+1 ; 0x01 frameControlFieldL &= ~(FRAME_VERSION_MASK); 8da: 8f 7c andi r24, 0xCF ; 207 frameControlFieldL |= (version << 4)&(FRAME_VERSION_MASK); *(startOfFrame+1) = (uint8_t) frameControlFieldL; 8dc: 81 83 std Z+1, r24 ; 0x01 } void setSourceAddressingMode(volatile uint8_t* startOfFrame, uint8_t addrMode){ uint8_t frameControlFieldL; frameControlFieldL = *(startOfFrame+1); 8de: 81 81 ldd r24, Z+1 ; 0x01 frameControlFieldL &= ~(SRC_ADDR_MODE_MASK); frameControlFieldL |= (addrMode << 6)&(SRC_ADDR_MODE_MASK); 8e0: 8f 73 andi r24, 0x3F ; 63 8e2: 80 68 ori r24, 0x80 ; 128 *(startOfFrame+1) = (uint8_t) frameControlFieldL; 8e4: 81 83 std Z+1, r24 ; 0x01 } void setSequenceNumber(volatile uint8_t* startOfFrame, uint8_t seqNumber){ *(startOfFrame + 2) = seqNumber; 8e6: e2 82 std Z+2, r14 ; 0x02 } void setDestinationPANID(volatile uint8_t* startOfFrame, uint16_t destPAN){ *(startOfFrame + 3) = (uint8_t) destPAN; 8e8: 9e ef ldi r25, 0xFE ; 254 8ea: 93 83 std Z+3, r25 ; 0x03 *(startOfFrame + 4) = (uint8_t) (destPAN >> 8); 8ec: 2a ec ldi r18, 0xCA ; 202 8ee: 24 83 std Z+4, r18 ; 0x04 } void setDestinationAddress(volatile uint8_t* startOfFrame, uint16_t destAddr){ *(startOfFrame + 5) = (uint8_t) destAddr; 8f0: 95 83 std Z+5, r25 ; 0x05 *(startOfFrame + 6) = (uint8_t) (destAddr >> 8); 8f2: 8f ea ldi r24, 0xAF ; 175 8f4: 86 83 std Z+6, r24 ; 0x06 } void setSourcePANID(volatile uint8_t* startOfFrame, uint16_t srcPAN){ *(startOfFrame + 7) = (uint8_t) srcPAN; 8f6: 97 83 std Z+7, r25 ; 0x07 *(startOfFrame + 8) = (uint8_t) (srcPAN >> 8); 8f8: 20 87 std Z+8, r18 ; 0x08 } void setSourceAddress(volatile uint8_t* startOfFrame, uint16_t srcAddr){ *(startOfFrame + 9) = (uint8_t) srcAddr; 8fa: 91 87 std Z+9, r25 ; 0x09 *(startOfFrame + 10) = (uint8_t) (srcAddr >> 8); 8fc: 92 87 std Z+10, r25 ; 0x0a } void setAppCommandByte(volatile uint8_t* startOfFrame, uint8_t command){ *(startOfFrame + 11) = command; 8fe: 8c ec ldi r24, 0xCC ; 204 900: 83 87 std Z+11, r24 ; 0x0b 902: 3c 96 adiw r30, 0x0c ; 12 904: 80 e0 ldi r24, 0x00 ; 0 906: 90 e0 ldi r25, 0x00 ; 0 } void setRandomPayload(volatile uint8_t* startOfFrame, uint8_t length){ for (int var = 0; var < length; ++var) { 908: 2f 2d mov r18, r15 90a: 30 e0 ldi r19, 0x00 ; 0 *(startOfFrame + 12 + var) = 0xFF; 90c: 4f ef ldi r20, 0xFF ; 255 90e: 02 c0 rjmp .+4 ; 0x914 910: 41 93 st Z+, r20 void setAppCommandByte(volatile uint8_t* startOfFrame, uint8_t command){ *(startOfFrame + 11) = command; } void setRandomPayload(volatile uint8_t* startOfFrame, uint8_t length){ for (int var = 0; var < length; ++var) { 912: 01 96 adiw r24, 0x01 ; 1 914: 82 17 cp r24, r18 916: 93 07 cpc r25, r19 918: dc f3 brlt .-10 ; 0x910 setDestinationAddress(startOfFrame, TEST_ADDR_SHORT_RX); setSourcePANID(startOfFrame, TEST_PANID); setSourceAddress(startOfFrame, TEST_ADDR_SHORT_TX); setAppCommandByte(startOfFrame, CHANNEL_CHANGE); setRandomPayload(startOfFrame, length); } 91a: 1f 91 pop r17 91c: 0f 91 pop r16 91e: ff 90 pop r15 920: ef 90 pop r14 922: 08 95 ret 00000924 : frameControlField |= ACK_REQUEST_MASK; *(startOfFrame) = (uint8_t) (frameControlField >> 8); *(startOfFrame + 1) = (uint8_t) frameControlField; } void setIntraPANFlag(volatile uint8_t* startOfFrame){ 924: fc 01 movw r30, r24 uint16_t frameControlField; frameControlField = (((uint16_t) *(startOfFrame)) << 8); 926: 80 81 ld r24, Z 928: 38 2f mov r19, r24 92a: 20 e0 ldi r18, 0x00 ; 0 frameControlField |= (uint16_t) *(startOfFrame + 1); 92c: 81 81 ldd r24, Z+1 ; 0x01 92e: 90 e0 ldi r25, 0x00 ; 0 930: 82 2b or r24, r18 932: 93 2b or r25, r19 frameControlField |= INTRA_PAN_MASK; 934: 90 64 ori r25, 0x40 ; 64 *(startOfFrame) = (uint8_t) (frameControlField >> 8); 936: 90 83 st Z, r25 *(startOfFrame + 1) = (uint8_t) frameControlField; 938: 81 83 std Z+1, r24 ; 0x01 } 93a: 08 95 ret 0000093c : void setDestinationAddressingMode(volatile uint8_t* startOfFrame, uint8_t addrMode){ 93c: fc 01 movw r30, r24 uint8_t frameControlFieldL; frameControlFieldL = *(startOfFrame+1); 93e: 81 81 ldd r24, Z+1 ; 0x01 frameControlFieldL &= ~(DEST_ADDR_MODE_MASK); frameControlFieldL |= (addrMode << 2)&(DEST_ADDR_MODE_MASK); 940: 66 0f add r22, r22 942: 66 0f add r22, r22 944: 6c 70 andi r22, 0x0C ; 12 946: 83 7f andi r24, 0xF3 ; 243 948: 86 2b or r24, r22 *(startOfFrame+1) = (uint8_t) frameControlFieldL; 94a: 81 83 std Z+1, r24 ; 0x01 } 94c: 08 95 ret 0000094e : void setFrameVersion(volatile uint8_t* startOfFrame, uint8_t version){ 94e: fc 01 movw r30, r24 uint8_t frameControlFieldL; frameControlFieldL = *(startOfFrame+1); 950: 81 81 ldd r24, Z+1 ; 0x01 frameControlFieldL &= ~(FRAME_VERSION_MASK); frameControlFieldL |= (version << 4)&(FRAME_VERSION_MASK); 952: 62 95 swap r22 954: 60 73 andi r22, 0x30 ; 48 956: 8f 7c andi r24, 0xCF ; 207 958: 86 2b or r24, r22 *(startOfFrame+1) = (uint8_t) frameControlFieldL; 95a: 81 83 std Z+1, r24 ; 0x01 } 95c: 08 95 ret 0000095e : void setSourceAddressingMode(volatile uint8_t* startOfFrame, uint8_t addrMode){ 95e: fc 01 movw r30, r24 uint8_t frameControlFieldL; frameControlFieldL = *(startOfFrame+1); 960: 81 81 ldd r24, Z+1 ; 0x01 frameControlFieldL &= ~(SRC_ADDR_MODE_MASK); frameControlFieldL |= (addrMode << 6)&(SRC_ADDR_MODE_MASK); 962: 62 95 swap r22 964: 66 0f add r22, r22 966: 66 0f add r22, r22 968: 60 7c andi r22, 0xC0 ; 192 96a: 8f 73 andi r24, 0x3F ; 63 96c: 86 2b or r24, r22 *(startOfFrame+1) = (uint8_t) frameControlFieldL; 96e: 81 83 std Z+1, r24 ; 0x01 } 970: 08 95 ret 00000972 : void setSequenceNumber(volatile uint8_t* startOfFrame, uint8_t seqNumber){ 972: fc 01 movw r30, r24 *(startOfFrame + 2) = seqNumber; 974: 62 83 std Z+2, r22 ; 0x02 } 976: 08 95 ret 00000978 : void setDestinationPANID(volatile uint8_t* startOfFrame, uint16_t destPAN){ 978: fc 01 movw r30, r24 *(startOfFrame + 3) = (uint8_t) destPAN; 97a: 63 83 std Z+3, r22 ; 0x03 *(startOfFrame + 4) = (uint8_t) (destPAN >> 8); 97c: 74 83 std Z+4, r23 ; 0x04 } 97e: 08 95 ret 00000980 : void setDestinationAddress(volatile uint8_t* startOfFrame, uint16_t destAddr){ 980: fc 01 movw r30, r24 *(startOfFrame + 5) = (uint8_t) destAddr; 982: 65 83 std Z+5, r22 ; 0x05 *(startOfFrame + 6) = (uint8_t) (destAddr >> 8); 984: 76 83 std Z+6, r23 ; 0x06 } 986: 08 95 ret 00000988 : void setSourcePANID(volatile uint8_t* startOfFrame, uint16_t srcPAN){ 988: fc 01 movw r30, r24 *(startOfFrame + 7) = (uint8_t) srcPAN; 98a: 67 83 std Z+7, r22 ; 0x07 *(startOfFrame + 8) = (uint8_t) (srcPAN >> 8); 98c: 70 87 std Z+8, r23 ; 0x08 } 98e: 08 95 ret 00000990 : void setSourceAddress(volatile uint8_t* startOfFrame, uint16_t srcAddr){ 990: fc 01 movw r30, r24 *(startOfFrame + 9) = (uint8_t) srcAddr; 992: 61 87 std Z+9, r22 ; 0x09 *(startOfFrame + 10) = (uint8_t) (srcAddr >> 8); 994: 72 87 std Z+10, r23 ; 0x0a } 996: 08 95 ret 00000998 : void setAppCommandByte(volatile uint8_t* startOfFrame, uint8_t command){ 998: fc 01 movw r30, r24 *(startOfFrame + 11) = command; 99a: 63 87 std Z+11, r22 ; 0x0b } 99c: 08 95 ret 0000099e : void setRandomPayload(volatile uint8_t* startOfFrame, uint8_t length){ 99e: fc 01 movw r30, r24 9a0: 3c 96 adiw r30, 0x0c ; 12 9a2: 80 e0 ldi r24, 0x00 ; 0 9a4: 90 e0 ldi r25, 0x00 ; 0 for (int var = 0; var < length; ++var) { 9a6: 70 e0 ldi r23, 0x00 ; 0 *(startOfFrame + 12 + var) = 0xFF; 9a8: 2f ef ldi r18, 0xFF ; 255 9aa: 02 c0 rjmp .+4 ; 0x9b0 9ac: 21 93 st Z+, r18 void setAppCommandByte(volatile uint8_t* startOfFrame, uint8_t command){ *(startOfFrame + 11) = command; } void setRandomPayload(volatile uint8_t* startOfFrame, uint8_t length){ for (int var = 0; var < length; ++var) { 9ae: 01 96 adiw r24, 0x01 ; 1 9b0: 86 17 cp r24, r22 9b2: 97 07 cpc r25, r23 9b4: dc f3 brlt .-10 ; 0x9ac *(startOfFrame + 12 + var) = 0xFF; } } 9b6: 08 95 ret 000009b8 : void clearSecurityEnabledFlag(volatile uint8_t* startOfFrame) { 9b8: fc 01 movw r30, r24 uint16_t frameControlField; frameControlField = (((uint16_t) *(startOfFrame)) << 8); 9ba: 80 81 ld r24, Z 9bc: 38 2f mov r19, r24 9be: 20 e0 ldi r18, 0x00 ; 0 frameControlField |= (uint16_t) *(startOfFrame + 1); 9c0: 81 81 ldd r24, Z+1 ; 0x01 9c2: 90 e0 ldi r25, 0x00 ; 0 9c4: 82 2b or r24, r18 9c6: 93 2b or r25, r19 frameControlField &= ~SECURITY_ENABLED_MASK; 9c8: 97 7f andi r25, 0xF7 ; 247 *(startOfFrame) = (uint8_t) (frameControlField >> 8); 9ca: 90 83 st Z, r25 *(startOfFrame + 1) = (uint8_t) frameControlField; 9cc: 81 83 std Z+1, r24 ; 0x01 } 9ce: 08 95 ret 000009d0 : void clearFramePendingFlag(volatile uint8_t* startOfFrame){ 9d0: fc 01 movw r30, r24 uint16_t frameControlField; frameControlField = (((uint16_t)*(startOfFrame)) << 8); 9d2: 80 81 ld r24, Z 9d4: 38 2f mov r19, r24 9d6: 20 e0 ldi r18, 0x00 ; 0 frameControlField |= (uint16_t) *(startOfFrame+1); 9d8: 81 81 ldd r24, Z+1 ; 0x01 9da: 90 e0 ldi r25, 0x00 ; 0 9dc: 82 2b or r24, r18 9de: 93 2b or r25, r19 frameControlField &= ~((uint16_t)FRAME_PENDING_MASK); 9e0: 9f 7e andi r25, 0xEF ; 239 *(startOfFrame) = (uint8_t)(frameControlField >> 8); 9e2: 90 83 st Z, r25 *(startOfFrame+1) = (uint8_t) frameControlField; 9e4: 81 83 std Z+1, r24 ; 0x01 } 9e6: 08 95 ret 000009e8 : void clearACKRequestFlag(volatile uint8_t* startOfFrame){ 9e8: fc 01 movw r30, r24 uint16_t frameControlField; frameControlField = (((uint16_t)*(startOfFrame)) << 8); 9ea: 80 81 ld r24, Z 9ec: 38 2f mov r19, r24 9ee: 20 e0 ldi r18, 0x00 ; 0 frameControlField |= (uint16_t) *(startOfFrame+1); 9f0: 81 81 ldd r24, Z+1 ; 0x01 9f2: 90 e0 ldi r25, 0x00 ; 0 9f4: 82 2b or r24, r18 9f6: 93 2b or r25, r19 frameControlField &= ~((uint16_t)ACK_REQUEST_MASK); 9f8: 9f 7d andi r25, 0xDF ; 223 *(startOfFrame) = (uint8_t)(frameControlField >> 8); 9fa: 90 83 st Z, r25 *(startOfFrame+1) = (uint8_t) frameControlField; 9fc: 81 83 std Z+1, r24 ; 0x01 } 9fe: 08 95 ret 00000a00 : void clearIntraPANFlag(volatile uint8_t* startOfFrame){ a00: fc 01 movw r30, r24 uint16_t frameControlField; frameControlField = (((uint16_t)*(startOfFrame)) << 8); a02: 80 81 ld r24, Z a04: 38 2f mov r19, r24 a06: 20 e0 ldi r18, 0x00 ; 0 frameControlField |= (uint16_t) *(startOfFrame+1); a08: 81 81 ldd r24, Z+1 ; 0x01 a0a: 90 e0 ldi r25, 0x00 ; 0 a0c: 82 2b or r24, r18 a0e: 93 2b or r25, r19 frameControlField &= ~((uint16_t)INTRA_PAN_MASK); a10: 9f 7b andi r25, 0xBF ; 191 *(startOfFrame) = (uint8_t)(frameControlField >> 8); a12: 90 83 st Z, r25 *(startOfFrame+1) = (uint8_t) frameControlField; a14: 81 83 std Z+1, r24 ; 0x01 } a16: 08 95 ret 00000a18 : /* GET operations*/ uint8_t getFrameType(volatile uint8_t* startOfFrame){ a18: fc 01 movw r30, r24 uint8_t frameControlFieldL; frameControlFieldL = *(startOfFrame); a1a: 80 81 ld r24, Z frameControlFieldL &= (FRAMETYPE_MASK >> 8); return (frameControlFieldL >> FRAMETYPE_POS); } a1c: 87 70 andi r24, 0x07 ; 7 a1e: 08 95 ret 00000a20 : uint8_t getSecurityEnabledFlag(volatile uint8_t* startOfFrame){ a20: fc 01 movw r30, r24 uint8_t frameControlFieldL; frameControlFieldL = *(startOfFrame); a22: 80 81 ld r24, Z a24: 88 70 andi r24, 0x08 ; 8 frameControlFieldL &= (SECURITY_ENABLED_MASK >> 8); return (frameControlFieldL >> SECURITY_ENABLED_POS); } a26: 86 95 lsr r24 a28: 86 95 lsr r24 a2a: 86 95 lsr r24 a2c: 08 95 ret 00000a2e : uint8_t getFramePendingFlag(volatile uint8_t* startOfFrame){ a2e: fc 01 movw r30, r24 uint8_t frameControlFieldL; frameControlFieldL = *(startOfFrame); a30: 80 81 ld r24, Z a32: 80 71 andi r24, 0x10 ; 16 frameControlFieldL &= (FRAME_PENDING_MASK >> 8); return (frameControlFieldL >> FRAME_PENDING_POS); } a34: 82 95 swap r24 a36: 8f 70 andi r24, 0x0F ; 15 a38: 08 95 ret 00000a3a : uint8_t getACKRequestFlag(volatile uint8_t* startOfFrame){ a3a: fc 01 movw r30, r24 uint8_t frameControlFieldL; frameControlFieldL = *(startOfFrame); a3c: 80 81 ld r24, Z a3e: 80 72 andi r24, 0x20 ; 32 frameControlFieldL &= (ACK_REQUEST_MASK >> 8); return (frameControlFieldL >> ACK_REQUEST_POS); } a40: 82 95 swap r24 a42: 86 95 lsr r24 a44: 87 70 andi r24, 0x07 ; 7 a46: 08 95 ret 00000a48 : uint8_t getIntraPANFlag(volatile uint8_t* startOfFrame){ a48: fc 01 movw r30, r24 uint8_t frameControlFieldL; frameControlFieldL = *(startOfFrame); a4a: 80 81 ld r24, Z a4c: 80 74 andi r24, 0x40 ; 64 frameControlFieldL &= (INTRA_PAN_MASK >> 8); return (frameControlFieldL >> INTRA_PAN_POS); } a4e: 82 95 swap r24 a50: 86 95 lsr r24 a52: 86 95 lsr r24 a54: 83 70 andi r24, 0x03 ; 3 a56: 08 95 ret 00000a58 : uint8_t getDestinationAddressingMode(volatile uint8_t* startOfFrame){ a58: fc 01 movw r30, r24 uint8_t frameControlFieldH; frameControlFieldH = *(startOfFrame+1); a5a: 81 81 ldd r24, Z+1 ; 0x01 frameControlFieldH &= (DEST_ADDR_MODE_MASK >> 8); return (frameControlFieldH >> DEST_ADDR_MODE_POS); } a5c: 80 e0 ldi r24, 0x00 ; 0 a5e: 08 95 ret 00000a60 : uint8_t getFrameVersion(volatile uint8_t* startOfFrame){ a60: fc 01 movw r30, r24 uint8_t frameControlFieldH; frameControlFieldH = *(startOfFrame + 1); a62: 81 81 ldd r24, Z+1 ; 0x01 frameControlFieldH &= (FRAME_VERSION_MASK >> 8); return (frameControlFieldH >> FRAME_VERSION_POS); } a64: 80 e0 ldi r24, 0x00 ; 0 a66: 08 95 ret 00000a68 : uint8_t getSourceAddressingMode(volatile uint8_t* startOfFrame){ a68: fc 01 movw r30, r24 uint8_t frameControlFieldH; frameControlFieldH = *(startOfFrame + 1); a6a: 81 81 ldd r24, Z+1 ; 0x01 frameControlFieldH &= (SRC_ADDR_MODE_MASK >> 8); return (frameControlFieldH >> SRC_ADDR_MODE_POS); } a6c: 80 e0 ldi r24, 0x00 ; 0 a6e: 08 95 ret 00000a70 : uint8_t getSequenceNumber(volatile uint8_t* startOfFrame){ a70: fc 01 movw r30, r24 return(*(startOfFrame + 2)); a72: 82 81 ldd r24, Z+2 ; 0x02 } a74: 08 95 ret 00000a76 : uint16_t getDestinationPANID(volatile uint8_t* startOfFrame){ a76: fc 01 movw r30, r24 uint16_t destPan; destPan = *(startOfFrame + 3); a78: 23 81 ldd r18, Z+3 ; 0x03 a7a: 30 e0 ldi r19, 0x00 ; 0 destPan |= ((uint16_t)*(startOfFrame + 4) << 8); a7c: 44 81 ldd r20, Z+4 ; 0x04 a7e: 94 2f mov r25, r20 a80: 80 e0 ldi r24, 0x00 ; 0 a82: 28 2b or r18, r24 a84: 39 2b or r19, r25 return destPan; } a86: c9 01 movw r24, r18 a88: 08 95 ret 00000a8a : uint16_t getDestinationAddress(volatile uint8_t* startOfFrame){ a8a: fc 01 movw r30, r24 uint16_t destAddr; destAddr = *(startOfFrame + 5); a8c: 25 81 ldd r18, Z+5 ; 0x05 a8e: 30 e0 ldi r19, 0x00 ; 0 destAddr |= ((uint16_t)*(startOfFrame + 6) << 8); a90: 46 81 ldd r20, Z+6 ; 0x06 a92: 94 2f mov r25, r20 a94: 80 e0 ldi r24, 0x00 ; 0 a96: 28 2b or r18, r24 a98: 39 2b or r19, r25 return destAddr; } a9a: c9 01 movw r24, r18 a9c: 08 95 ret 00000a9e : uint16_t getSourcePANID(volatile uint8_t* startOfFrame){ a9e: fc 01 movw r30, r24 uint16_t srcPan; srcPan = *(startOfFrame + 7); aa0: 27 81 ldd r18, Z+7 ; 0x07 aa2: 30 e0 ldi r19, 0x00 ; 0 srcPan |= ((uint16_t)*(startOfFrame + 8) << 8); aa4: 40 85 ldd r20, Z+8 ; 0x08 aa6: 94 2f mov r25, r20 aa8: 80 e0 ldi r24, 0x00 ; 0 aaa: 28 2b or r18, r24 aac: 39 2b or r19, r25 return srcPan; } aae: c9 01 movw r24, r18 ab0: 08 95 ret 00000ab2 : uint16_t getSourceAddress(volatile uint8_t* startOfFrame){ ab2: fc 01 movw r30, r24 uint16_t srcAddr; srcAddr = *(startOfFrame + 9); ab4: 21 85 ldd r18, Z+9 ; 0x09 ab6: 30 e0 ldi r19, 0x00 ; 0 srcAddr |= ((uint16_t)*(startOfFrame + 10) << 8); ab8: 42 85 ldd r20, Z+10 ; 0x0a aba: 94 2f mov r25, r20 abc: 80 e0 ldi r24, 0x00 ; 0 abe: 28 2b or r18, r24 ac0: 39 2b or r19, r25 return srcAddr; } ac2: c9 01 movw r24, r18 ac4: 08 95 ret 00000ac6 : uint8_t getAppCommandByte(volatile uint8_t* startOfFrame){ ac6: fc 01 movw r30, r24 return(*(startOfFrame + 11)); ac8: 83 85 ldd r24, Z+11 ; 0x0b } aca: 08 95 ret 00000acc : uint8_t getLQI(volatile uint8_t* lastbyte){ acc: fc 01 movw r30, r24 return(*lastbyte); ace: 80 81 ld r24, Z } ad0: 08 95 ret 00000ad2 <__vector_25>: ISR(USART0_RX_vect) /************************************************************************* Function: UART Receive Complete interrupt Purpose: called when the UART has received a character **************************************************************************/ { ad2: 1f 92 push r1 ad4: 0f 92 push r0 ad6: 0f b6 in r0, 0x3f ; 63 ad8: 0f 92 push r0 ada: 0b b6 in r0, 0x3b ; 59 adc: 0f 92 push r0 ade: 11 24 eor r1, r1 ae0: 2f 93 push r18 ae2: 8f 93 push r24 ae4: 9f 93 push r25 ae6: ef 93 push r30 ae8: ff 93 push r31 unsigned char usr; unsigned char lastRxError; /* read UART status register and UART data register */ usr = UART0_STATUS; aea: 90 91 c0 00 lds r25, 0x00C0 data = UART0_DATA; aee: 20 91 c6 00 lds r18, 0x00C6 #elif defined ( ATMEGA_UART ) lastRxError = (usr & (_BV(FE)|_BV(DOR)) ); #endif /* calculate buffer index */ tmphead = ( UART_RxHead + 1) & UART_RX_BUFFER_MASK; af2: e0 91 8b 03 lds r30, 0x038B af6: ef 5f subi r30, 0xFF ; 255 af8: ef 71 andi r30, 0x1F ; 31 if ( tmphead == UART_RxTail ) { afa: 80 91 8c 03 lds r24, 0x038C afe: e8 17 cp r30, r24 b00: 11 f4 brne .+4 ; 0xb06 <__vector_25+0x34> b02: 82 e0 ldi r24, 0x02 ; 2 b04: 08 c0 rjmp .+16 ; 0xb16 <__vector_25+0x44> #if defined( AT90_UART ) lastRxError = (usr & (_BV(FE)|_BV(DOR)) ); #elif defined( ATMEGA_USART ) lastRxError = (usr & (_BV(FE)|_BV(DOR)) ); #elif defined( ATMEGA_USART0 ) lastRxError = (usr & (_BV(FE0)|_BV(DOR0)) ); b06: 89 2f mov r24, r25 b08: 88 71 andi r24, 0x18 ; 24 if ( tmphead == UART_RxTail ) { /* error: receive buffer overflow */ lastRxError = UART_BUFFER_OVERFLOW >> 8; }else{ /* store new index */ UART_RxHead = tmphead; b0a: e0 93 8b 03 sts 0x038B, r30 /* store received data in buffer */ UART_RxBuf[tmphead] = data; b0e: f0 e0 ldi r31, 0x00 ; 0 b10: e7 59 subi r30, 0x97 ; 151 b12: fc 4f sbci r31, 0xFC ; 252 b14: 20 83 st Z, r18 } UART_LastRxError = lastRxError; b16: 80 93 8d 03 sts 0x038D, r24 } b1a: ff 91 pop r31 b1c: ef 91 pop r30 b1e: 9f 91 pop r25 b20: 8f 91 pop r24 b22: 2f 91 pop r18 b24: 0f 90 pop r0 b26: 0b be out 0x3b, r0 ; 59 b28: 0f 90 pop r0 b2a: 0f be out 0x3f, r0 ; 63 b2c: 0f 90 pop r0 b2e: 1f 90 pop r1 b30: 18 95 reti 00000b32 <__vector_26>: ISR(UART0_TRANSMIT_INTERRUPT) /************************************************************************* Function: UART Data Register Empty interrupt Purpose: called when the UART is ready to transmit the next byte **************************************************************************/ { b32: 1f 92 push r1 b34: 0f 92 push r0 b36: 0f b6 in r0, 0x3f ; 63 b38: 0f 92 push r0 b3a: 0b b6 in r0, 0x3b ; 59 b3c: 0f 92 push r0 b3e: 11 24 eor r1, r1 b40: 8f 93 push r24 b42: 9f 93 push r25 b44: ef 93 push r30 b46: ff 93 push r31 unsigned char tmptail; if ( UART_TxHead != UART_TxTail) { b48: 90 91 89 03 lds r25, 0x0389 b4c: 80 91 8a 03 lds r24, 0x038A b50: 98 17 cp r25, r24 b52: 69 f0 breq .+26 ; 0xb6e <__vector_26+0x3c> /* calculate and store new buffer index */ tmptail = (UART_TxTail + 1) & UART_TX_BUFFER_MASK; b54: e0 91 8a 03 lds r30, 0x038A b58: ef 5f subi r30, 0xFF ; 255 b5a: ef 71 andi r30, 0x1F ; 31 UART_TxTail = tmptail; b5c: e0 93 8a 03 sts 0x038A, r30 /* get one byte from buffer and write it to UART */ UART0_DATA = UART_TxBuf[tmptail]; /* start transmission */ b60: f0 e0 ldi r31, 0x00 ; 0 b62: e7 5b subi r30, 0xB7 ; 183 b64: fc 4f sbci r31, 0xFC ; 252 b66: 80 81 ld r24, Z b68: 80 93 c6 00 sts 0x00C6, r24 b6c: 05 c0 rjmp .+10 ; 0xb78 <__vector_26+0x46> }else{ /* tx buffer empty, disable UDRE interrupt */ UART0_CONTROL &= ~_BV(UART0_UDRIE); b6e: 80 91 c1 00 lds r24, 0x00C1 b72: 8f 7d andi r24, 0xDF ; 223 b74: 80 93 c1 00 sts 0x00C1, r24 } } b78: ff 91 pop r31 b7a: ef 91 pop r30 b7c: 9f 91 pop r25 b7e: 8f 91 pop r24 b80: 0f 90 pop r0 b82: 0b be out 0x3b, r0 ; 59 b84: 0f 90 pop r0 b86: 0f be out 0x3f, r0 ; 63 b88: 0f 90 pop r0 b8a: 1f 90 pop r1 b8c: 18 95 reti 00000b8e : Purpose: initialize UART and set baudrate Input: baudrate using macro UART_BAUD_SELECT() Returns: none **************************************************************************/ extern void uart_init(unsigned int baudrate) { b8e: 9c 01 movw r18, r24 UART_TxHead = 0; b90: 10 92 89 03 sts 0x0389, r1 UART_TxTail = 0; b94: 10 92 8a 03 sts 0x038A, r1 UART_RxHead = 0; b98: 10 92 8b 03 sts 0x038B, r1 UART_RxTail = 0; b9c: 10 92 8c 03 sts 0x038C, r1 UCSRC = (3< { UART0_STATUS = (1<>8); bac: 30 93 c5 00 sts 0x00C5, r19 UBRR0L = (unsigned char) baudrate; bb0: 20 93 c4 00 sts 0x00C4, r18 /* Enable USART receiver and transmitter and receive complete interrupt */ UART0_CONTROL = _BV(RXCIE0)|(1<: { unsigned char tmptail; unsigned char data; if ( UART_RxHead == UART_RxTail ) { bc2: 90 91 8b 03 lds r25, 0x038B bc6: 80 91 8c 03 lds r24, 0x038C bca: 98 17 cp r25, r24 bcc: 19 f4 brne .+6 ; 0xbd4 bce: 20 e0 ldi r18, 0x00 ; 0 bd0: 31 e0 ldi r19, 0x01 ; 1 bd2: 12 c0 rjmp .+36 ; 0xbf8 return UART_NO_DATA; /* no data available */ } /* calculate /store buffer index */ tmptail = (UART_RxTail + 1) & UART_RX_BUFFER_MASK; bd4: e0 91 8c 03 lds r30, 0x038C bd8: ef 5f subi r30, 0xFF ; 255 bda: ef 71 andi r30, 0x1F ; 31 UART_RxTail = tmptail; bdc: e0 93 8c 03 sts 0x038C, r30 /* get data from receive buffer */ data = UART_RxBuf[tmptail]; be0: f0 e0 ldi r31, 0x00 ; 0 be2: e7 59 subi r30, 0x97 ; 151 be4: fc 4f sbci r31, 0xFC ; 252 be6: 30 81 ld r19, Z return (UART_LastRxError << 8) + data; be8: 20 91 8d 03 lds r18, 0x038D bec: 92 2f mov r25, r18 bee: 80 e0 ldi r24, 0x00 ; 0 bf0: ac 01 movw r20, r24 bf2: 43 0f add r20, r19 bf4: 51 1d adc r21, r1 bf6: 9a 01 movw r18, r20 }/* uart_getc */ bf8: c9 01 movw r24, r18 bfa: 08 95 ret 00000bfc : Function: uart_writeByte() Purpose: write byte to ringbuffer for transmitting via UART Input: byte to be transmitted Returns: none **************************************************************************/ void uart_writeByte(char data) { bfc: 28 2f mov r18, r24 unsigned char tmphead; tmphead = (UART_TxHead + 1) & UART_TX_BUFFER_MASK; bfe: 90 91 89 03 lds r25, 0x0389 c02: 9f 5f subi r25, 0xFF ; 255 c04: 9f 71 andi r25, 0x1F ; 31 while (tmphead == UART_TxTail) { c06: 80 91 8a 03 lds r24, 0x038A c0a: 98 17 cp r25, r24 c0c: e1 f3 breq .-8 ; 0xc06 ;/* wait for free space in buffer */ } UART_TxBuf[tmphead] = data; c0e: e9 2f mov r30, r25 c10: f0 e0 ldi r31, 0x00 ; 0 c12: e7 5b subi r30, 0xB7 ; 183 c14: fc 4f sbci r31, 0xFC ; 252 c16: 20 83 st Z, r18 UART_TxHead = tmphead; c18: 90 93 89 03 sts 0x0389, r25 /* enable UDRE interrupt */ UART0_CONTROL |= _BV(UART0_UDRIE); c1c: 80 91 c1 00 lds r24, 0x00C1 c20: 80 62 ori r24, 0x20 ; 32 c22: 80 93 c1 00 sts 0x00C1, r24 }/* uart_writeByte */ c26: 08 95 ret 00000c28 : Purpose: transmit string to UART Input: string to be transmitted Returns: none **************************************************************************/ void uart_writeString(const char *s ) { c28: cf 93 push r28 c2a: df 93 push r29 c2c: ec 01 movw r28, r24 c2e: 03 c0 rjmp .+6 ; 0xc36 while (*s) uart_writeByte(*s++); c30: 21 96 adiw r28, 0x01 ; 1 c32: 0e 94 fe 05 call 0xbfc ; 0xbfc Input: string to be transmitted Returns: none **************************************************************************/ void uart_writeString(const char *s ) { while (*s) c36: 88 81 ld r24, Y c38: 88 23 and r24, r24 c3a: d1 f7 brne .-12 ; 0xc30 // { // break; // } // uart_writeByte(s[i]); // } }/* uart_writeString */ c3c: df 91 pop r29 c3e: cf 91 pop r28 c40: 08 95 ret 00000c42 : Purpose: transmit string to UART Input: string to be transmitted Returns: none **************************************************************************/ void uart_writeNewline(void){ uart_writeString("\n\r\0"); c42: 8c e3 ldi r24, 0x3C ; 60 c44: 93 e0 ldi r25, 0x03 ; 3 c46: 0e 94 14 06 call 0xc28 ; 0xc28 } c4a: 08 95 ret 00000c4c : Purpose: transmit string to UART Input: string to be transmitted Returns: none **************************************************************************/ void uart_writeLine(const char *line){ uart_writeString(line); c4c: 0e 94 14 06 call 0xc28 ; 0xc28 uart_writeNewline(); c50: 0e 94 21 06 call 0xc42 ; 0xc42 } c54: 08 95 ret 00000c56 : Purpose: transmit string from program memory to UART Input: program memory string to be transmitted Returns: none **************************************************************************/ void uart_writeProgString(const char *progmem_s ) { c56: cf 93 push r28 c58: df 93 push r29 c5a: ec 01 movw r28, r24 c5c: 02 c0 rjmp .+4 ; 0xc62 register char c; while ( (c = pgm_read_byte(progmem_s++)) ) uart_writeByte(c); c5e: 0e 94 fe 05 call 0xbfc ; 0xbfc c62: fe 01 movw r30, r28 **************************************************************************/ void uart_writeProgString(const char *progmem_s ) { register char c; while ( (c = pgm_read_byte(progmem_s++)) ) c64: 21 96 adiw r28, 0x01 ; 1 c66: 84 91 lpm r24, Z+ c68: 88 23 and r24, r24 c6a: c9 f7 brne .-14 ; 0xc5e uart_writeByte(c); }/* uart_writeProgString */ c6c: df 91 pop r29 c6e: cf 91 pop r28 c70: 08 95 ret 00000c72 <__vector_36>: ISR(UART1_RECEIVE_INTERRUPT) /************************************************************************* Function: UART1 Receive Complete interrupt Purpose: called when the UART1 has received a character **************************************************************************/ { c72: 1f 92 push r1 c74: 0f 92 push r0 c76: 0f b6 in r0, 0x3f ; 63 c78: 0f 92 push r0 c7a: 0b b6 in r0, 0x3b ; 59 c7c: 0f 92 push r0 c7e: 11 24 eor r1, r1 c80: 2f 93 push r18 c82: 8f 93 push r24 c84: 9f 93 push r25 c86: ef 93 push r30 c88: ff 93 push r31 unsigned char usr; unsigned char lastRxError; /* read UART status register and UART data register */ usr = UART1_STATUS; c8a: 90 91 c8 00 lds r25, 0x00C8 data = UART1_DATA; c8e: 20 91 ce 00 lds r18, 0x00CE /* */ lastRxError = (usr & (_BV(FE1)|_BV(DOR1)) ); /* calculate buffer index */ tmphead = ( UART1_RxHead + 1) & UART_RX_BUFFER_MASK; c92: e0 91 d0 03 lds r30, 0x03D0 c96: ef 5f subi r30, 0xFF ; 255 c98: ef 71 andi r30, 0x1F ; 31 if ( tmphead == UART1_RxTail ) { c9a: 80 91 d1 03 lds r24, 0x03D1 c9e: e8 17 cp r30, r24 ca0: 11 f4 brne .+4 ; 0xca6 <__vector_36+0x34> ca2: 82 e0 ldi r24, 0x02 ; 2 ca4: 08 c0 rjmp .+16 ; 0xcb6 <__vector_36+0x44> /* read UART status register and UART data register */ usr = UART1_STATUS; data = UART1_DATA; /* */ lastRxError = (usr & (_BV(FE1)|_BV(DOR1)) ); ca6: 89 2f mov r24, r25 ca8: 88 71 andi r24, 0x18 ; 24 if ( tmphead == UART1_RxTail ) { /* error: receive buffer overflow */ lastRxError = UART_BUFFER_OVERFLOW >> 8; }else{ /* store new index */ UART1_RxHead = tmphead; caa: e0 93 d0 03 sts 0x03D0, r30 /* store received data in buffer */ UART1_RxBuf[tmphead] = data; cae: f0 e0 ldi r31, 0x00 ; 0 cb0: e2 55 subi r30, 0x52 ; 82 cb2: fc 4f sbci r31, 0xFC ; 252 cb4: 20 83 st Z, r18 } UART1_LastRxError = lastRxError; cb6: 80 93 d2 03 sts 0x03D2, r24 } cba: ff 91 pop r31 cbc: ef 91 pop r30 cbe: 9f 91 pop r25 cc0: 8f 91 pop r24 cc2: 2f 91 pop r18 cc4: 0f 90 pop r0 cc6: 0b be out 0x3b, r0 ; 59 cc8: 0f 90 pop r0 cca: 0f be out 0x3f, r0 ; 63 ccc: 0f 90 pop r0 cce: 1f 90 pop r1 cd0: 18 95 reti 00000cd2 <__vector_37>: ISR(UART1_TRANSMIT_INTERRUPT) /************************************************************************* Function: UART1 Data Register Empty interrupt Purpose: called when the UART1 is ready to transmit the next byte **************************************************************************/ { cd2: 1f 92 push r1 cd4: 0f 92 push r0 cd6: 0f b6 in r0, 0x3f ; 63 cd8: 0f 92 push r0 cda: 0b b6 in r0, 0x3b ; 59 cdc: 0f 92 push r0 cde: 11 24 eor r1, r1 ce0: 8f 93 push r24 ce2: 9f 93 push r25 ce4: ef 93 push r30 ce6: ff 93 push r31 unsigned char tmptail; if ( UART1_TxHead != UART1_TxTail) { ce8: 90 91 ce 03 lds r25, 0x03CE cec: 80 91 cf 03 lds r24, 0x03CF cf0: 98 17 cp r25, r24 cf2: 69 f0 breq .+26 ; 0xd0e <__vector_37+0x3c> /* calculate and store new buffer index */ tmptail = (UART1_TxTail + 1) & UART_TX_BUFFER_MASK; cf4: e0 91 cf 03 lds r30, 0x03CF cf8: ef 5f subi r30, 0xFF ; 255 cfa: ef 71 andi r30, 0x1F ; 31 UART1_TxTail = tmptail; cfc: e0 93 cf 03 sts 0x03CF, r30 /* get one byte from buffer and write it to UART */ UART1_DATA = UART1_TxBuf[tmptail]; /* start transmission */ d00: f0 e0 ldi r31, 0x00 ; 0 d02: e2 57 subi r30, 0x72 ; 114 d04: fc 4f sbci r31, 0xFC ; 252 d06: 80 81 ld r24, Z d08: 80 93 ce 00 sts 0x00CE, r24 d0c: 05 c0 rjmp .+10 ; 0xd18 <__vector_37+0x46> }else{ /* tx buffer empty, disable UDRE interrupt */ UART1_CONTROL &= ~_BV(UART1_UDRIE); d0e: 80 91 c9 00 lds r24, 0x00C9 d12: 8f 7d andi r24, 0xDF ; 223 d14: 80 93 c9 00 sts 0x00C9, r24 } } d18: ff 91 pop r31 d1a: ef 91 pop r30 d1c: 9f 91 pop r25 d1e: 8f 91 pop r24 d20: 0f 90 pop r0 d22: 0b be out 0x3b, r0 ; 59 d24: 0f 90 pop r0 d26: 0f be out 0x3f, r0 ; 63 d28: 0f 90 pop r0 d2a: 1f 90 pop r1 d2c: 18 95 reti 00000d2e : Purpose: initialize UART1 and set baudrate Input: baudrate using macro UART_BAUD_SELECT() Returns: none **************************************************************************/ void uart1_init(unsigned int baudrate) { d2e: 9c 01 movw r18, r24 UART1_TxHead = 0; d30: 10 92 ce 03 sts 0x03CE, r1 UART1_TxTail = 0; d34: 10 92 cf 03 sts 0x03CF, r1 UART1_RxHead = 0; d38: 10 92 d0 03 sts 0x03D0, r1 UART1_RxTail = 0; d3c: 10 92 d1 03 sts 0x03D1, r1 /* Set baud rate */ if ( baudrate & 0x8000 ) d40: 97 ff sbrs r25, 7 d42: 04 c0 rjmp .+8 ; 0xd4c { UART1_STATUS = (1<>8); d4c: 30 93 cd 00 sts 0x00CD, r19 UBRR1L = (unsigned char) baudrate; d50: 20 93 cc 00 sts 0x00CC, r18 /* Enable USART receiver and transmitter and receive complete interrupt */ UART1_CONTROL = _BV(RXCIE1)|(1<: { unsigned char tmptail; unsigned char data; if ( UART1_RxHead == UART1_RxTail ) { d62: 90 91 d0 03 lds r25, 0x03D0 d66: 80 91 d1 03 lds r24, 0x03D1 d6a: 98 17 cp r25, r24 d6c: 19 f4 brne .+6 ; 0xd74 d6e: 20 e0 ldi r18, 0x00 ; 0 d70: 31 e0 ldi r19, 0x01 ; 1 d72: 12 c0 rjmp .+36 ; 0xd98 return UART_NO_DATA; /* no data available */ } /* calculate /store buffer index */ tmptail = (UART1_RxTail + 1) & UART_RX_BUFFER_MASK; d74: e0 91 d1 03 lds r30, 0x03D1 d78: ef 5f subi r30, 0xFF ; 255 d7a: ef 71 andi r30, 0x1F ; 31 UART1_RxTail = tmptail; d7c: e0 93 d1 03 sts 0x03D1, r30 /* get data from receive buffer */ data = UART1_RxBuf[tmptail]; d80: f0 e0 ldi r31, 0x00 ; 0 d82: e2 55 subi r30, 0x52 ; 82 d84: fc 4f sbci r31, 0xFC ; 252 d86: 30 81 ld r19, Z return (UART1_LastRxError << 8) + data; d88: 20 91 d2 03 lds r18, 0x03D2 d8c: 92 2f mov r25, r18 d8e: 80 e0 ldi r24, 0x00 ; 0 d90: ac 01 movw r20, r24 d92: 43 0f add r20, r19 d94: 51 1d adc r21, r1 d96: 9a 01 movw r18, r20 }/* uart1_getc */ d98: c9 01 movw r24, r18 d9a: 08 95 ret 00000d9c : Purpose: write byte to ringbuffer for transmitting via UART Input: byte to be transmitted Returns: none **************************************************************************/ void uart1_putc(unsigned char data) { d9c: 28 2f mov r18, r24 unsigned char tmphead; tmphead = (UART1_TxHead + 1) & UART_TX_BUFFER_MASK; d9e: 90 91 ce 03 lds r25, 0x03CE da2: 9f 5f subi r25, 0xFF ; 255 da4: 9f 71 andi r25, 0x1F ; 31 while ( tmphead == UART1_TxTail ){ da6: 80 91 cf 03 lds r24, 0x03CF daa: 98 17 cp r25, r24 dac: e1 f3 breq .-8 ; 0xda6 ;/* wait for free space in buffer */ } UART1_TxBuf[tmphead] = data; dae: e9 2f mov r30, r25 db0: f0 e0 ldi r31, 0x00 ; 0 db2: e2 57 subi r30, 0x72 ; 114 db4: fc 4f sbci r31, 0xFC ; 252 db6: 20 83 st Z, r18 UART1_TxHead = tmphead; db8: 90 93 ce 03 sts 0x03CE, r25 /* enable UDRE interrupt */ UART1_CONTROL |= _BV(UART1_UDRIE); dbc: 80 91 c9 00 lds r24, 0x00C9 dc0: 80 62 ori r24, 0x20 ; 32 dc2: 80 93 c9 00 sts 0x00C9, r24 }/* uart1_putc */ dc6: 08 95 ret 00000dc8 : Purpose: transmit string to UART1 Input: string to be transmitted Returns: none **************************************************************************/ void uart1_puts(const char *s ) { dc8: cf 93 push r28 dca: df 93 push r29 dcc: ec 01 movw r28, r24 dce: 03 c0 rjmp .+6 ; 0xdd6 while (*s) uart1_putc(*s++); dd0: 21 96 adiw r28, 0x01 ; 1 dd2: 0e 94 ce 06 call 0xd9c ; 0xd9c Input: string to be transmitted Returns: none **************************************************************************/ void uart1_puts(const char *s ) { while (*s) dd6: 88 81 ld r24, Y dd8: 88 23 and r24, r24 dda: d1 f7 brne .-12 ; 0xdd0 uart1_putc(*s++); }/* uart1_puts */ ddc: df 91 pop r29 dde: cf 91 pop r28 de0: 08 95 ret 00000de2 : Purpose: transmit string from program memory to UART1 Input: program memory string to be transmitted Returns: none **************************************************************************/ void uart1_puts_p(const char *progmem_s ) { de2: cf 93 push r28 de4: df 93 push r29 de6: ec 01 movw r28, r24 de8: 02 c0 rjmp .+4 ; 0xdee register char c; while ( (c = pgm_read_byte(progmem_s++)) ) uart1_putc(c); dea: 0e 94 ce 06 call 0xd9c ; 0xd9c dee: fe 01 movw r30, r28 **************************************************************************/ void uart1_puts_p(const char *progmem_s ) { register char c; while ( (c = pgm_read_byte(progmem_s++)) ) df0: 21 96 adiw r28, 0x01 ; 1 df2: 84 91 lpm r24, Z+ df4: 88 23 and r24, r24 df6: c9 f7 brne .-14 ; 0xdea uart1_putc(c); }/* uart1_puts_p */ df8: df 91 pop r29 dfa: cf 91 pop r28 dfc: 08 95 ret 00000dfe : Function: uart_writeNumberBin() Purpose: transmit string to UART Input: string to be transmitted Returns: none **************************************************************************/ void uart_writeNumberBin(const int32_t value){ dfe: 0f 93 push r16 e00: 1f 93 push r17 e02: df 93 push r29 e04: cf 93 push r28 e06: cd b7 in r28, 0x3d ; 61 e08: de b7 in r29, 0x3e ; 62 e0a: a0 97 sbiw r28, 0x20 ; 32 e0c: 0f b6 in r0, 0x3f ; 63 e0e: f8 94 cli e10: de bf out 0x3e, r29 ; 62 e12: 0f be out 0x3f, r0 ; 63 e14: cd bf out 0x3d, r28 ; 61 e16: dc 01 movw r26, r24 e18: cb 01 movw r24, r22 char numBuffer[32]; itoa(value, numBuffer, 2); e1a: 8e 01 movw r16, r28 e1c: 0f 5f subi r16, 0xFF ; 255 e1e: 1f 4f sbci r17, 0xFF ; 255 e20: b8 01 movw r22, r16 e22: 42 e0 ldi r20, 0x02 ; 2 e24: 50 e0 ldi r21, 0x00 ; 0 e26: 0e 94 86 08 call 0x110c ; 0x110c uart_writeString(numBuffer); e2a: c8 01 movw r24, r16 e2c: 0e 94 14 06 call 0xc28 ; 0xc28 } e30: a0 96 adiw r28, 0x20 ; 32 e32: 0f b6 in r0, 0x3f ; 63 e34: f8 94 cli e36: de bf out 0x3e, r29 ; 62 e38: 0f be out 0x3f, r0 ; 63 e3a: cd bf out 0x3d, r28 ; 61 e3c: cf 91 pop r28 e3e: df 91 pop r29 e40: 1f 91 pop r17 e42: 0f 91 pop r16 e44: 08 95 ret 00000e46 : uart_writeString("}"); } } } void uart_writeArrayU8Bin(uint8_t* array, uint8_t length) { e46: ef 92 push r14 e48: ff 92 push r15 e4a: 0f 93 push r16 e4c: 1f 93 push r17 e4e: cf 93 push r28 e50: df 93 push r29 e52: 18 2f mov r17, r24 e54: 09 2f mov r16, r25 e56: e6 2e mov r14, r22 uart_writeString("{"); e58: 80 e4 ldi r24, 0x40 ; 64 e5a: 93 e0 ldi r25, 0x03 ; 3 e5c: 0e 94 14 06 call 0xc28 ; 0xc28 e60: 21 2f mov r18, r17 e62: 30 2f mov r19, r16 e64: c9 01 movw r24, r18 e66: ec 01 movw r28, r24 e68: ff 24 eor r15, r15 uint8_t i; for (i = 0; i < length; i++) { uart_writeNumberBin(array[i]); if (i != length - 1) { e6a: 0e 2d mov r16, r14 e6c: 10 e0 ldi r17, 0x00 ; 0 e6e: 01 50 subi r16, 0x01 ; 1 e70: 10 40 sbci r17, 0x00 ; 0 e72: 14 c0 rjmp .+40 ; 0xe9c void uart_writeArrayU8Bin(uint8_t* array, uint8_t length) { uart_writeString("{"); uint8_t i; for (i = 0; i < length; i++) { uart_writeNumberBin(array[i]); e74: 68 81 ld r22, Y e76: 70 e0 ldi r23, 0x00 ; 0 e78: 80 e0 ldi r24, 0x00 ; 0 e7a: 90 e0 ldi r25, 0x00 ; 0 e7c: 0e 94 ff 06 call 0xdfe ; 0xdfe if (i != length - 1) { e80: 8f 2d mov r24, r15 e82: 90 e0 ldi r25, 0x00 ; 0 e84: 80 17 cp r24, r16 e86: 91 07 cpc r25, r17 e88: 19 f0 breq .+6 ; 0xe90 uart_writeString("; "); e8a: 82 e4 ldi r24, 0x42 ; 66 e8c: 93 e0 ldi r25, 0x03 ; 3 e8e: 02 c0 rjmp .+4 ; 0xe94 } else { uart_writeString("}"); e90: 85 e4 ldi r24, 0x45 ; 69 e92: 93 e0 ldi r25, 0x03 ; 3 e94: 0e 94 14 06 call 0xc28 ; 0xc28 } void uart_writeArrayU8Bin(uint8_t* array, uint8_t length) { uart_writeString("{"); uint8_t i; for (i = 0; i < length; i++) { e98: f3 94 inc r15 e9a: 21 96 adiw r28, 0x01 ; 1 e9c: fe 14 cp r15, r14 e9e: 50 f3 brcs .-44 ; 0xe74 uart_writeString("; "); } else { uart_writeString("}"); } } } ea0: df 91 pop r29 ea2: cf 91 pop r28 ea4: 1f 91 pop r17 ea6: 0f 91 pop r16 ea8: ff 90 pop r15 eaa: ef 90 pop r14 eac: 08 95 ret 00000eae : Function: uart_writeNumberHex() Purpose: transmit string to UART Input: string to be transmitted Returns: none **************************************************************************/ void uart_writeNumberHex(const int32_t value) { eae: 0f 93 push r16 eb0: 1f 93 push r17 eb2: df 93 push r29 eb4: cf 93 push r28 eb6: cd b7 in r28, 0x3d ; 61 eb8: de b7 in r29, 0x3e ; 62 eba: 28 97 sbiw r28, 0x08 ; 8 ebc: 0f b6 in r0, 0x3f ; 63 ebe: f8 94 cli ec0: de bf out 0x3e, r29 ; 62 ec2: 0f be out 0x3f, r0 ; 63 ec4: cd bf out 0x3d, r28 ; 61 ec6: dc 01 movw r26, r24 ec8: cb 01 movw r24, r22 char numBuffer[8]; itoa(value, numBuffer, 16); eca: 8e 01 movw r16, r28 ecc: 0f 5f subi r16, 0xFF ; 255 ece: 1f 4f sbci r17, 0xFF ; 255 ed0: b8 01 movw r22, r16 ed2: 40 e1 ldi r20, 0x10 ; 16 ed4: 50 e0 ldi r21, 0x00 ; 0 ed6: 0e 94 86 08 call 0x110c ; 0x110c uart_writeString(numBuffer); eda: c8 01 movw r24, r16 edc: 0e 94 14 06 call 0xc28 ; 0xc28 } ee0: 28 96 adiw r28, 0x08 ; 8 ee2: 0f b6 in r0, 0x3f ; 63 ee4: f8 94 cli ee6: de bf out 0x3e, r29 ; 62 ee8: 0f be out 0x3f, r0 ; 63 eea: cd bf out 0x3d, r28 ; 61 eec: cf 91 pop r28 eee: df 91 pop r29 ef0: 1f 91 pop r17 ef2: 0f 91 pop r16 ef4: 08 95 ret 00000ef6 : uart_writeString("}"); } } } void uart_writeArrayU8Hex(uint8_t* array, uint8_t length) { ef6: ef 92 push r14 ef8: ff 92 push r15 efa: 0f 93 push r16 efc: 1f 93 push r17 efe: cf 93 push r28 f00: df 93 push r29 f02: 18 2f mov r17, r24 f04: 09 2f mov r16, r25 f06: e6 2e mov r14, r22 uart_writeString("{"); f08: 80 e4 ldi r24, 0x40 ; 64 f0a: 93 e0 ldi r25, 0x03 ; 3 f0c: 0e 94 14 06 call 0xc28 ; 0xc28 f10: 21 2f mov r18, r17 f12: 30 2f mov r19, r16 f14: c9 01 movw r24, r18 f16: ec 01 movw r28, r24 f18: ff 24 eor r15, r15 uint8_t i; for (i = 0; i < length; i++) { uart_writeNumberHex(array[i]); if (i != length - 1) { f1a: 0e 2d mov r16, r14 f1c: 10 e0 ldi r17, 0x00 ; 0 f1e: 01 50 subi r16, 0x01 ; 1 f20: 10 40 sbci r17, 0x00 ; 0 f22: 14 c0 rjmp .+40 ; 0xf4c void uart_writeArrayU8Hex(uint8_t* array, uint8_t length) { uart_writeString("{"); uint8_t i; for (i = 0; i < length; i++) { uart_writeNumberHex(array[i]); f24: 68 81 ld r22, Y f26: 70 e0 ldi r23, 0x00 ; 0 f28: 80 e0 ldi r24, 0x00 ; 0 f2a: 90 e0 ldi r25, 0x00 ; 0 f2c: 0e 94 57 07 call 0xeae ; 0xeae if (i != length - 1) { f30: 8f 2d mov r24, r15 f32: 90 e0 ldi r25, 0x00 ; 0 f34: 80 17 cp r24, r16 f36: 91 07 cpc r25, r17 f38: 19 f0 breq .+6 ; 0xf40 uart_writeString("; "); f3a: 82 e4 ldi r24, 0x42 ; 66 f3c: 93 e0 ldi r25, 0x03 ; 3 f3e: 02 c0 rjmp .+4 ; 0xf44 } else { uart_writeString("}"); f40: 85 e4 ldi r24, 0x45 ; 69 f42: 93 e0 ldi r25, 0x03 ; 3 f44: 0e 94 14 06 call 0xc28 ; 0xc28 } void uart_writeArrayU8Hex(uint8_t* array, uint8_t length) { uart_writeString("{"); uint8_t i; for (i = 0; i < length; i++) { f48: f3 94 inc r15 f4a: 21 96 adiw r28, 0x01 ; 1 f4c: fe 14 cp r15, r14 f4e: 50 f3 brcs .-44 ; 0xf24 uart_writeString("; "); } else { uart_writeString("}"); } } } f50: df 91 pop r29 f52: cf 91 pop r28 f54: 1f 91 pop r17 f56: 0f 91 pop r16 f58: ff 90 pop r15 f5a: ef 90 pop r14 f5c: 08 95 ret 00000f5e : Function: uart_writeNumberDec() Purpose: transmit string to UART Input: string to be transmitted Returns: none **************************************************************************/ void uart_writeNumberDec(const int32_t value){ f5e: 0f 93 push r16 f60: 1f 93 push r17 f62: df 93 push r29 f64: cf 93 push r28 f66: cd b7 in r28, 0x3d ; 61 f68: de b7 in r29, 0x3e ; 62 f6a: 2a 97 sbiw r28, 0x0a ; 10 f6c: 0f b6 in r0, 0x3f ; 63 f6e: f8 94 cli f70: de bf out 0x3e, r29 ; 62 f72: 0f be out 0x3f, r0 ; 63 f74: cd bf out 0x3d, r28 ; 61 f76: dc 01 movw r26, r24 f78: cb 01 movw r24, r22 char numBuffer[10]; itoa(value, numBuffer, 10); f7a: 8e 01 movw r16, r28 f7c: 0f 5f subi r16, 0xFF ; 255 f7e: 1f 4f sbci r17, 0xFF ; 255 f80: b8 01 movw r22, r16 f82: 4a e0 ldi r20, 0x0A ; 10 f84: 50 e0 ldi r21, 0x00 ; 0 f86: 0e 94 86 08 call 0x110c ; 0x110c uart_writeString(numBuffer); f8a: c8 01 movw r24, r16 f8c: 0e 94 14 06 call 0xc28 ; 0xc28 } f90: 2a 96 adiw r28, 0x0a ; 10 f92: 0f b6 in r0, 0x3f ; 63 f94: f8 94 cli f96: de bf out 0x3e, r29 ; 62 f98: 0f be out 0x3f, r0 ; 63 f9a: cd bf out 0x3d, r28 ; 61 f9c: cf 91 pop r28 f9e: df 91 pop r29 fa0: 1f 91 pop r17 fa2: 0f 91 pop r16 fa4: 08 95 ret 00000fa6 : /* * these functions are only for ATmegas with two USART */ void uart_writeArrayU8Dec(uint8_t* array, uint8_t length) { fa6: ef 92 push r14 fa8: ff 92 push r15 faa: 0f 93 push r16 fac: 1f 93 push r17 fae: cf 93 push r28 fb0: df 93 push r29 fb2: 18 2f mov r17, r24 fb4: 09 2f mov r16, r25 fb6: e6 2e mov r14, r22 uart_writeString("{"); fb8: 80 e4 ldi r24, 0x40 ; 64 fba: 93 e0 ldi r25, 0x03 ; 3 fbc: 0e 94 14 06 call 0xc28 ; 0xc28 fc0: 21 2f mov r18, r17 fc2: 30 2f mov r19, r16 fc4: c9 01 movw r24, r18 fc6: ec 01 movw r28, r24 fc8: ff 24 eor r15, r15 uint8_t i; for (i = 0; i < length; i++) { uart_writeNumberDec(array[i]); if (i != length - 1) { fca: 0e 2d mov r16, r14 fcc: 10 e0 ldi r17, 0x00 ; 0 fce: 01 50 subi r16, 0x01 ; 1 fd0: 10 40 sbci r17, 0x00 ; 0 fd2: 14 c0 rjmp .+40 ; 0xffc void uart_writeArrayU8Dec(uint8_t* array, uint8_t length) { uart_writeString("{"); uint8_t i; for (i = 0; i < length; i++) { uart_writeNumberDec(array[i]); fd4: 68 81 ld r22, Y fd6: 70 e0 ldi r23, 0x00 ; 0 fd8: 80 e0 ldi r24, 0x00 ; 0 fda: 90 e0 ldi r25, 0x00 ; 0 fdc: 0e 94 af 07 call 0xf5e ; 0xf5e if (i != length - 1) { fe0: 8f 2d mov r24, r15 fe2: 90 e0 ldi r25, 0x00 ; 0 fe4: 80 17 cp r24, r16 fe6: 91 07 cpc r25, r17 fe8: 19 f0 breq .+6 ; 0xff0 uart_writeString("; "); fea: 82 e4 ldi r24, 0x42 ; 66 fec: 93 e0 ldi r25, 0x03 ; 3 fee: 02 c0 rjmp .+4 ; 0xff4 } else { uart_writeString("}"); ff0: 85 e4 ldi r24, 0x45 ; 69 ff2: 93 e0 ldi r25, 0x03 ; 3 ff4: 0e 94 14 06 call 0xc28 ; 0xc28 */ void uart_writeArrayU8Dec(uint8_t* array, uint8_t length) { uart_writeString("{"); uint8_t i; for (i = 0; i < length; i++) { ff8: f3 94 inc r15 ffa: 21 96 adiw r28, 0x01 ; 1 ffc: fe 14 cp r15, r14 ffe: 50 f3 brcs .-44 ; 0xfd4 uart_writeString("; "); } else { uart_writeString("}"); } } } 1000: df 91 pop r29 1002: cf 91 pop r28 1004: 1f 91 pop r17 1006: 0f 91 pop r16 1008: ff 90 pop r15 100a: ef 90 pop r14 100c: 08 95 ret 0000100e <__lshrdi3>: 100e: ef 92 push r14 1010: ff 92 push r15 1012: 0f 93 push r16 1014: df 93 push r29 1016: cf 93 push r28 1018: cd b7 in r28, 0x3d ; 61 101a: de b7 in r29, 0x3e ; 62 101c: 60 97 sbiw r28, 0x10 ; 16 101e: 0f b6 in r0, 0x3f ; 63 1020: f8 94 cli 1022: de bf out 0x3e, r29 ; 62 1024: 0f be out 0x3f, r0 ; 63 1026: cd bf out 0x3d, r28 ; 61 1028: a8 2f mov r26, r24 102a: 00 23 and r16, r16 102c: 09 f4 brne .+2 ; 0x1030 <__lshrdi3+0x22> 102e: 61 c0 rjmp .+194 ; 0x10f2 <__lshrdi3+0xe4> 1030: 7e 01 movw r14, r28 1032: 08 94 sec 1034: e1 1c adc r14, r1 1036: f1 1c adc r15, r1 1038: 88 e0 ldi r24, 0x08 ; 8 103a: f7 01 movw r30, r14 103c: 11 92 st Z+, r1 103e: 8a 95 dec r24 1040: e9 f7 brne .-6 ; 0x103c <__lshrdi3+0x2e> 1042: 29 83 std Y+1, r18 ; 0x01 1044: 3a 83 std Y+2, r19 ; 0x02 1046: 4b 83 std Y+3, r20 ; 0x03 1048: 5c 83 std Y+4, r21 ; 0x04 104a: 6d 83 std Y+5, r22 ; 0x05 104c: 7e 83 std Y+6, r23 ; 0x06 104e: af 83 std Y+7, r26 ; 0x07 1050: 98 87 std Y+8, r25 ; 0x08 1052: 80 e2 ldi r24, 0x20 ; 32 1054: 80 1b sub r24, r16 1056: e8 2f mov r30, r24 1058: ff 27 eor r31, r31 105a: e7 fd sbrc r30, 7 105c: f0 95 com r31 105e: 4d 81 ldd r20, Y+5 ; 0x05 1060: 5e 81 ldd r21, Y+6 ; 0x06 1062: 6f 81 ldd r22, Y+7 ; 0x07 1064: 78 85 ldd r23, Y+8 ; 0x08 1066: 18 16 cp r1, r24 1068: 84 f0 brlt .+32 ; 0x108a <__lshrdi3+0x7c> 106a: 1d 86 std Y+13, r1 ; 0x0d 106c: 1e 86 std Y+14, r1 ; 0x0e 106e: 1f 86 std Y+15, r1 ; 0x0f 1070: 18 8a std Y+16, r1 ; 0x10 1072: 88 27 eor r24, r24 1074: 99 27 eor r25, r25 1076: 8e 1b sub r24, r30 1078: 9f 0b sbc r25, r31 107a: 04 c0 rjmp .+8 ; 0x1084 <__lshrdi3+0x76> 107c: 76 95 lsr r23 107e: 67 95 ror r22 1080: 57 95 ror r21 1082: 47 95 ror r20 1084: 8a 95 dec r24 1086: d2 f7 brpl .-12 ; 0x107c <__lshrdi3+0x6e> 1088: 28 c0 rjmp .+80 ; 0x10da <__lshrdi3+0xcc> 108a: 20 2f mov r18, r16 108c: 33 27 eor r19, r19 108e: 27 fd sbrc r18, 7 1090: 30 95 com r19 1092: db 01 movw r26, r22 1094: ca 01 movw r24, r20 1096: 02 2e mov r0, r18 1098: 04 c0 rjmp .+8 ; 0x10a2 <__lshrdi3+0x94> 109a: b6 95 lsr r27 109c: a7 95 ror r26 109e: 97 95 ror r25 10a0: 87 95 ror r24 10a2: 0a 94 dec r0 10a4: d2 f7 brpl .-12 ; 0x109a <__lshrdi3+0x8c> 10a6: 8d 87 std Y+13, r24 ; 0x0d 10a8: 9e 87 std Y+14, r25 ; 0x0e 10aa: af 87 std Y+15, r26 ; 0x0f 10ac: b8 8b std Y+16, r27 ; 0x10 10ae: 04 c0 rjmp .+8 ; 0x10b8 <__lshrdi3+0xaa> 10b0: 44 0f add r20, r20 10b2: 55 1f adc r21, r21 10b4: 66 1f adc r22, r22 10b6: 77 1f adc r23, r23 10b8: ea 95 dec r30 10ba: d2 f7 brpl .-12 ; 0x10b0 <__lshrdi3+0xa2> 10bc: 89 81 ldd r24, Y+1 ; 0x01 10be: 9a 81 ldd r25, Y+2 ; 0x02 10c0: ab 81 ldd r26, Y+3 ; 0x03 10c2: bc 81 ldd r27, Y+4 ; 0x04 10c4: 04 c0 rjmp .+8 ; 0x10ce <__lshrdi3+0xc0> 10c6: b6 95 lsr r27 10c8: a7 95 ror r26 10ca: 97 95 ror r25 10cc: 87 95 ror r24 10ce: 2a 95 dec r18 10d0: d2 f7 brpl .-12 ; 0x10c6 <__lshrdi3+0xb8> 10d2: 48 2b or r20, r24 10d4: 59 2b or r21, r25 10d6: 6a 2b or r22, r26 10d8: 7b 2b or r23, r27 10da: 49 87 std Y+9, r20 ; 0x09 10dc: 5a 87 std Y+10, r21 ; 0x0a 10de: 6b 87 std Y+11, r22 ; 0x0b 10e0: 7c 87 std Y+12, r23 ; 0x0c 10e2: 29 85 ldd r18, Y+9 ; 0x09 10e4: 3a 85 ldd r19, Y+10 ; 0x0a 10e6: 4b 85 ldd r20, Y+11 ; 0x0b 10e8: 5c 85 ldd r21, Y+12 ; 0x0c 10ea: 6d 85 ldd r22, Y+13 ; 0x0d 10ec: 7e 85 ldd r23, Y+14 ; 0x0e 10ee: af 85 ldd r26, Y+15 ; 0x0f 10f0: 98 89 ldd r25, Y+16 ; 0x10 10f2: 8a 2f mov r24, r26 10f4: 60 96 adiw r28, 0x10 ; 16 10f6: 0f b6 in r0, 0x3f ; 63 10f8: f8 94 cli 10fa: de bf out 0x3e, r29 ; 62 10fc: 0f be out 0x3f, r0 ; 63 10fe: cd bf out 0x3d, r28 ; 61 1100: cf 91 pop r28 1102: df 91 pop r29 1104: 0f 91 pop r16 1106: ff 90 pop r15 1108: ef 90 pop r14 110a: 08 95 ret 0000110c : 110c: fb 01 movw r30, r22 110e: 9f 01 movw r18, r30 1110: e8 94 clt 1112: 42 30 cpi r20, 0x02 ; 2 1114: c4 f0 brlt .+48 ; 0x1146 1116: 45 32 cpi r20, 0x25 ; 37 1118: b4 f4 brge .+44 ; 0x1146 111a: 4a 30 cpi r20, 0x0A ; 10 111c: 29 f4 brne .+10 ; 0x1128 111e: 97 fb bst r25, 7 1120: 1e f4 brtc .+6 ; 0x1128 1122: 90 95 com r25 1124: 81 95 neg r24 1126: 9f 4f sbci r25, 0xFF ; 255 1128: 64 2f mov r22, r20 112a: 77 27 eor r23, r23 112c: 0e 94 b7 08 call 0x116e ; 0x116e <__udivmodhi4> 1130: 80 5d subi r24, 0xD0 ; 208 1132: 8a 33 cpi r24, 0x3A ; 58 1134: 0c f0 brlt .+2 ; 0x1138 1136: 89 5d subi r24, 0xD9 ; 217 1138: 81 93 st Z+, r24 113a: cb 01 movw r24, r22 113c: 00 97 sbiw r24, 0x00 ; 0 113e: a1 f7 brne .-24 ; 0x1128 1140: 16 f4 brtc .+4 ; 0x1146 1142: 5d e2 ldi r21, 0x2D ; 45 1144: 51 93 st Z+, r21 1146: 10 82 st Z, r1 1148: c9 01 movw r24, r18 114a: 0c 94 a7 08 jmp 0x114e ; 0x114e 0000114e : 114e: dc 01 movw r26, r24 1150: fc 01 movw r30, r24 1152: 67 2f mov r22, r23 1154: 71 91 ld r23, Z+ 1156: 77 23 and r23, r23 1158: e1 f7 brne .-8 ; 0x1152 115a: 32 97 sbiw r30, 0x02 ; 2 115c: 04 c0 rjmp .+8 ; 0x1166 115e: 7c 91 ld r23, X 1160: 6d 93 st X+, r22 1162: 70 83 st Z, r23 1164: 62 91 ld r22, -Z 1166: ae 17 cp r26, r30 1168: bf 07 cpc r27, r31 116a: c8 f3 brcs .-14 ; 0x115e 116c: 08 95 ret 0000116e <__udivmodhi4>: 116e: aa 1b sub r26, r26 1170: bb 1b sub r27, r27 1172: 51 e1 ldi r21, 0x11 ; 17 1174: 07 c0 rjmp .+14 ; 0x1184 <__udivmodhi4_ep> 00001176 <__udivmodhi4_loop>: 1176: aa 1f adc r26, r26 1178: bb 1f adc r27, r27 117a: a6 17 cp r26, r22 117c: b7 07 cpc r27, r23 117e: 10 f0 brcs .+4 ; 0x1184 <__udivmodhi4_ep> 1180: a6 1b sub r26, r22 1182: b7 0b sbc r27, r23 00001184 <__udivmodhi4_ep>: 1184: 88 1f adc r24, r24 1186: 99 1f adc r25, r25 1188: 5a 95 dec r21 118a: a9 f7 brne .-22 ; 0x1176 <__udivmodhi4_loop> 118c: 80 95 com r24 118e: 90 95 com r25 1190: bc 01 movw r22, r24 1192: cd 01 movw r24, r26 1194: 08 95 ret 00001196 <_exit>: 1196: f8 94 cli 00001198 <__stop_program>: 1198: ff cf rjmp .-2 ; 0x1198 <__stop_program>