nano_os.elf: file format elf32-avr Sections: Idx Name Size VMA LMA File off Algn 0 .data 00000008 00800100 00001998 00001a2c 2**0 CONTENTS, ALLOC, LOAD, DATA 1 .text 00001998 00000000 00000000 00000094 2**1 CONTENTS, ALLOC, LOAD, READONLY, CODE 2 .bss 00000116 00800108 00800108 00001a34 2**0 ALLOC 3 .stab 000006b4 00000000 00000000 00001a34 2**2 CONTENTS, READONLY, DEBUGGING 4 .stabstr 00000082 00000000 00000000 000020e8 2**0 CONTENTS, READONLY, DEBUGGING 5 .debug_aranges 00000048 00000000 00000000 0000216a 2**0 CONTENTS, READONLY, DEBUGGING 6 .debug_pubnames 0000036a 00000000 00000000 000021b2 2**0 CONTENTS, READONLY, DEBUGGING 7 .debug_info 00001163 00000000 00000000 0000251c 2**0 CONTENTS, READONLY, DEBUGGING 8 .debug_abbrev 0000046a 00000000 00000000 0000367f 2**0 CONTENTS, READONLY, DEBUGGING 9 .debug_line 000017ea 00000000 00000000 00003ae9 2**0 CONTENTS, READONLY, DEBUGGING 10 .debug_frame 00000230 00000000 00000000 000052d4 2**2 CONTENTS, READONLY, DEBUGGING 11 .debug_str 00000532 00000000 00000000 00005504 2**0 CONTENTS, READONLY, DEBUGGING 12 .debug_loc 00000ddb 00000000 00000000 00005a36 2**0 CONTENTS, READONLY, DEBUGGING 13 .debug_ranges 00000308 00000000 00000000 00006811 2**0 CONTENTS, READONLY, DEBUGGING Disassembly of section .text: 00000000 <__vectors>: 0: 0c 94 34 00 jmp 0x68 ; 0x68 <__ctors_end> 4: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 8: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> c: 0c 94 27 06 jmp 0xc4e ; 0xc4e <__vector_3> 10: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 14: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 18: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 1c: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 20: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 24: 0c 94 c1 06 jmp 0xd82 ; 0xd82 <__vector_9> 28: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 2c: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 30: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 34: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 38: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 3c: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 40: 0c 94 23 0b jmp 0x1646 ; 0x1646 <__vector_16> 44: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 48: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 4c: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 50: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 54: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 58: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 5c: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 60: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 64: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 00000068 <__ctors_end>: 68: 11 24 eor r1, r1 6a: 1f be out 0x3f, r1 ; 63 6c: cf ef ldi r28, 0xFF ; 255 6e: d4 e0 ldi r29, 0x04 ; 4 70: de bf out 0x3e, r29 ; 62 72: cd bf out 0x3d, r28 ; 61 00000074 <__do_copy_data>: 74: 11 e0 ldi r17, 0x01 ; 1 76: a0 e0 ldi r26, 0x00 ; 0 78: b1 e0 ldi r27, 0x01 ; 1 7a: e8 e9 ldi r30, 0x98 ; 152 7c: f9 e1 ldi r31, 0x19 ; 25 7e: 02 c0 rjmp .+4 ; 0x84 <.do_copy_data_start> 00000080 <.do_copy_data_loop>: 80: 05 90 lpm r0, Z+ 82: 0d 92 st X+, r0 00000084 <.do_copy_data_start>: 84: a8 30 cpi r26, 0x08 ; 8 86: b1 07 cpc r27, r17 88: d9 f7 brne .-10 ; 0x80 <.do_copy_data_loop> 0000008a <__do_clear_bss>: 8a: 12 e0 ldi r17, 0x02 ; 2 8c: a8 e0 ldi r26, 0x08 ; 8 8e: b1 e0 ldi r27, 0x01 ; 1 90: 01 c0 rjmp .+2 ; 0x94 <.do_clear_bss_start> 00000092 <.do_clear_bss_loop>: 92: 1d 92 st X+, r1 00000094 <.do_clear_bss_start>: 94: ae 31 cpi r26, 0x1E ; 30 96: b1 07 cpc r27, r17 98: e1 f7 brne .-8 ; 0x92 <.do_clear_bss_loop> 9a: 0e 94 15 07 call 0xe2a ; 0xe2a
9e: 0c 94 ca 0c jmp 0x1994 ; 0x1994 <_exit> 000000a2 <__bad_interrupt>: a2: 0c 94 00 00 jmp 0 ; 0x0 <__vectors> 000000a6 : //**************************************************** void scheduler() { //save R0-31 to current->stack PUSH(31);PUSH(30);PUSH(29);PUSH(28);PUSH(27);PUSH(26);PUSH(25);PUSH(24); a6: ff 93 push r31 a8: ef 93 push r30 aa: df 93 push r29 ac: cf 93 push r28 ae: bf 93 push r27 b0: af 93 push r26 b2: 9f 93 push r25 b4: 8f 93 push r24 PUSH(23);PUSH(22);PUSH(21);PUSH(20);PUSH(19);PUSH(18);PUSH(17);PUSH(16); b6: 7f 93 push r23 b8: 6f 93 push r22 ba: 5f 93 push r21 bc: 4f 93 push r20 be: 3f 93 push r19 c0: 2f 93 push r18 c2: 1f 93 push r17 c4: 0f 93 push r16 PUSH(15);PUSH(14);PUSH(13);PUSH(12);PUSH(11);PUSH(10);PUSH( 9);PUSH( 8); c6: ff 92 push r15 c8: ef 92 push r14 ca: df 92 push r13 cc: cf 92 push r12 ce: bf 92 push r11 d0: af 92 push r10 d2: 9f 92 push r9 d4: 8f 92 push r8 PUSH( 7);PUSH( 6);PUSH( 5);PUSH( 4);PUSH( 3);PUSH( 2);PUSH( 1);PUSH( 0); d6: 7f 92 push r7 d8: 6f 92 push r6 da: 5f 92 push r5 dc: 4f 92 push r4 de: 3f 92 push r3 e0: 2f 92 push r2 e2: 1f 92 push r1 e4: 0f 92 push r0 TIMER_REG = CLK1024; e6: 85 e0 ldi r24, 0x05 ; 5 e8: 85 bd out 0x25, r24 ; 37 //save SREG and SP if (currentTask >= 0) ea: 80 91 00 01 lds r24, 0x0100 ee: 87 fd sbrc r24, 7 f0: 17 c0 rjmp .+46 ; 0x120 { current = tasks[currentTask]; f2: e0 91 00 01 lds r30, 0x0100 f6: ff 27 eor r31, r31 f8: e7 fd sbrc r30, 7 fa: f0 95 com r31 fc: ee 0f add r30, r30 fe: ff 1f adc r31, r31 100: ea 5e subi r30, 0xEA ; 234 102: fe 4f sbci r31, 0xFE ; 254 104: 01 90 ld r0, Z+ 106: f0 81 ld r31, Z 108: e0 2d mov r30, r0 10a: f0 93 09 01 sts 0x0109, r31 10e: e0 93 08 01 sts 0x0108, r30 current->sreg = SREG; 112: 8f b7 in r24, 0x3f ; 63 114: 81 83 std Z+1, r24 ; 0x01 current->sp = (unsigned char *)(SP + 32); 116: 8d b7 in r24, 0x3d ; 61 118: 9e b7 in r25, 0x3e ; 62 11a: 80 96 adiw r24, 0x20 ; 32 11c: 93 83 std Z+3, r25 ; 0x03 11e: 82 83 std Z+2, r24 ; 0x02 } //switch to next task do { currentTask++; 120: 80 91 00 01 lds r24, 0x0100 124: 8f 5f subi r24, 0xFF ; 255 126: 80 93 00 01 sts 0x0100, r24 if (currentTask >= NUMBER) 12a: 80 91 00 01 lds r24, 0x0100 12e: 80 31 cpi r24, 0x10 ; 16 130: 14 f0 brlt .+4 ; 0x136 { currentTask = 0; 132: 10 92 00 01 sts 0x0100, r1 } current = tasks[currentTask]; 136: e0 91 00 01 lds r30, 0x0100 13a: ff 27 eor r31, r31 13c: e7 fd sbrc r30, 7 13e: f0 95 com r31 140: ee 0f add r30, r30 142: ff 1f adc r31, r31 144: ea 5e subi r30, 0xEA ; 234 146: fe 4f sbci r31, 0xFE ; 254 148: 01 90 ld r0, Z+ 14a: f0 81 ld r31, Z 14c: e0 2d mov r30, r0 } #ifdef TASK_USE_SIGNAL while (!(current && current->state==TaskStateActive)); #else while (!current); 14e: 30 97 sbiw r30, 0x00 ; 0 150: 39 f3 breq .-50 ; 0x120 152: f0 93 09 01 sts 0x0109, r31 156: e0 93 08 01 sts 0x0108, r30 #endif //restore this task (SREG, SP and R0...31) if (current) { TCNT0 = current->prio; 15a: 84 81 ldd r24, Z+4 ; 0x04 15c: 86 bd out 0x26, r24 ; 38 SREG = current->sreg; 15e: 81 81 ldd r24, Z+1 ; 0x01 160: 8f bf out 0x3f, r24 ; 63 SP = (unsigned int)(current->sp - 32); 162: 82 81 ldd r24, Z+2 ; 0x02 164: 93 81 ldd r25, Z+3 ; 0x03 166: 80 97 sbiw r24, 0x20 ; 32 168: 9e bf out 0x3e, r25 ; 62 16a: 8d bf out 0x3d, r24 ; 61 } POP( 0);POP( 1);POP( 2);POP( 3);POP( 4);POP( 5);POP( 6);POP( 7); 16c: 0f 90 pop r0 16e: 1f 90 pop r1 170: 2f 90 pop r2 172: 3f 90 pop r3 174: 4f 90 pop r4 176: 5f 90 pop r5 178: 6f 90 pop r6 17a: 7f 90 pop r7 POP( 8);POP( 9);POP(10);POP(11);POP(12);POP(13);POP(14);POP(15); 17c: 8f 90 pop r8 17e: 9f 90 pop r9 180: af 90 pop r10 182: bf 90 pop r11 184: cf 90 pop r12 186: df 90 pop r13 188: ef 90 pop r14 18a: ff 90 pop r15 POP(16);POP(17);POP(18);POP(19);POP(20);POP(21);POP(22);POP(23); 18c: 0f 91 pop r16 18e: 1f 91 pop r17 190: 2f 91 pop r18 192: 3f 91 pop r19 194: 4f 91 pop r20 196: 5f 91 pop r21 198: 6f 91 pop r22 19a: 7f 91 pop r23 POP(24);POP(25);POP(26);POP(27);POP(28);POP(29);POP(30);POP(31); 19c: 8f 91 pop r24 19e: 9f 91 pop r25 1a0: af 91 pop r26 1a2: bf 91 pop r27 1a4: cf 91 pop r28 1a6: df 91 pop r29 1a8: ef 91 pop r30 1aa: ff 91 pop r31 asm volatile("reti"); 1ac: 18 95 reti } 1ae: 08 95 ret 000001b0 : //* Prio: Priority * //* output: none * //**************************************************** void task_create(Task *t, TaskFunction f, TaskPrio prio) { 1b0: dc 01 movw r26, r24 sregsys = SREG; 1b2: 8f b7 in r24, 0x3f ; 63 1b4: 80 93 0a 01 sts 0x010A, r24 cli(); 1b8: f8 94 cli signed char a; unsigned char *s = (unsigned char *)(t->stack + sizeof(t->stack) - 3); 1ba: 9d 01 movw r18, r26 1bc: 2e 5b subi r18, 0xBE ; 190 1be: 3f 4f sbci r19, 0xFF ; 255 1c0: f9 01 movw r30, r18 1c2: 80 e2 ldi r24, 0x20 ; 32 for (a=31; a>=0; a--) *s-- = 0; 1c4: 10 82 st Z, r1 1c6: 31 97 sbiw r30, 0x01 ; 1 1c8: 81 50 subi r24, 0x01 ; 1 1ca: e1 f7 brne .-8 ; 0x1c4 //init kontext: sreg = 0, SP = Pointer to t->stack (which contains the stack section and the PC) t->sreg = 0; 1cc: 11 96 adiw r26, 0x01 ; 1 1ce: 1c 92 st X, r1 1d0: 11 97 sbiw r26, 0x01 ; 1 t->sp = (unsigned char *)(t->stack + sizeof(t->stack) - 3); 1d2: 13 96 adiw r26, 0x03 ; 3 1d4: 3c 93 st X, r19 1d6: 2e 93 st -X, r18 1d8: 12 97 sbiw r26, 0x02 ; 2 t->prio = prio; 1da: 14 96 adiw r26, 0x04 ; 4 1dc: 4c 93 st X, r20 1de: 14 97 sbiw r26, 0x04 ; 4 t->stack[sizeof(t->stack)-2] = ((unsigned int)f)>>8; 1e0: ad 5b subi r26, 0xBD ; 189 1e2: bf 4f sbci r27, 0xFF ; 255 1e4: 7d 93 st X+, r23 t->stack[sizeof(t->stack)-1] = ((unsigned int)f)&0xff; 1e6: 6c 93 st X, r22 1e8: a4 54 subi r26, 0x44 ; 68 1ea: b0 40 sbci r27, 0x00 ; 0 t->laps = 0; #endif for (a=0; a 1f8: 7a c0 rjmp .+244 ; 0x2ee 1fa: 80 91 18 01 lds r24, 0x0118 1fe: 90 91 19 01 lds r25, 0x0119 202: 89 2b or r24, r25 204: 09 f4 brne .+2 ; 0x208 206: 77 c0 rjmp .+238 ; 0x2f6 208: 80 91 1a 01 lds r24, 0x011A 20c: 90 91 1b 01 lds r25, 0x011B 210: 89 2b or r24, r25 212: 09 f4 brne .+2 ; 0x216 214: 78 c0 rjmp .+240 ; 0x306 216: 80 91 1c 01 lds r24, 0x011C 21a: 90 91 1d 01 lds r25, 0x011D 21e: 89 2b or r24, r25 220: 09 f4 brne .+2 ; 0x224 222: 6d c0 rjmp .+218 ; 0x2fe 224: 80 91 1e 01 lds r24, 0x011E 228: 90 91 1f 01 lds r25, 0x011F 22c: 89 2b or r24, r25 22e: 09 f4 brne .+2 ; 0x232 230: 72 c0 rjmp .+228 ; 0x316 232: 80 91 20 01 lds r24, 0x0120 236: 90 91 21 01 lds r25, 0x0121 23a: 89 2b or r24, r25 23c: 09 f4 brne .+2 ; 0x240 23e: 67 c0 rjmp .+206 ; 0x30e 240: 80 91 22 01 lds r24, 0x0122 244: 90 91 23 01 lds r25, 0x0123 248: 89 2b or r24, r25 24a: 09 f4 brne .+2 ; 0x24e 24c: 6c c0 rjmp .+216 ; 0x326 24e: 80 91 24 01 lds r24, 0x0124 252: 90 91 25 01 lds r25, 0x0125 256: 89 2b or r24, r25 258: 09 f4 brne .+2 ; 0x25c 25a: 61 c0 rjmp .+194 ; 0x31e 25c: 80 91 26 01 lds r24, 0x0126 260: 90 91 27 01 lds r25, 0x0127 264: 89 2b or r24, r25 266: 09 f4 brne .+2 ; 0x26a 268: 6a c0 rjmp .+212 ; 0x33e 26a: 80 91 28 01 lds r24, 0x0128 26e: 90 91 29 01 lds r25, 0x0129 272: 89 2b or r24, r25 274: 09 f4 brne .+2 ; 0x278 276: 5f c0 rjmp .+190 ; 0x336 278: 80 91 2a 01 lds r24, 0x012A 27c: 90 91 2b 01 lds r25, 0x012B 280: 89 2b or r24, r25 282: 09 f4 brne .+2 ; 0x286 284: 54 c0 rjmp .+168 ; 0x32e 286: 80 91 2c 01 lds r24, 0x012C 28a: 90 91 2d 01 lds r25, 0x012D 28e: 89 2b or r24, r25 290: 09 f4 brne .+2 ; 0x294 292: 61 c0 rjmp .+194 ; 0x356 294: 80 91 2e 01 lds r24, 0x012E 298: 90 91 2f 01 lds r25, 0x012F 29c: 89 2b or r24, r25 29e: 09 f4 brne .+2 ; 0x2a2 2a0: 56 c0 rjmp .+172 ; 0x34e 2a2: 80 91 30 01 lds r24, 0x0130 2a6: 90 91 31 01 lds r25, 0x0131 2aa: 89 2b or r24, r25 2ac: 09 f4 brne .+2 ; 0x2b0 2ae: 4b c0 rjmp .+150 ; 0x346 2b0: 80 91 32 01 lds r24, 0x0132 2b4: 90 91 33 01 lds r25, 0x0133 2b8: 89 2b or r24, r25 2ba: 09 f4 brne .+2 ; 0x2be 2bc: 50 c0 rjmp .+160 ; 0x35e 2be: 80 91 34 01 lds r24, 0x0134 2c2: 90 91 35 01 lds r25, 0x0135 2c6: 89 2b or r24, r25 2c8: 21 f0 breq .+8 ; 0x2d2 t->ID = a; tasks[a] = t; break; } } SREG = sregsys; 2ca: 80 91 0a 01 lds r24, 0x010A 2ce: 8f bf out 0x3f, r24 ; 63 return; } 2d0: 08 95 ret t->laps = 0; #endif for (a=0; aID = a; 2d8: 8c 93 st X, r24 tasks[a] = t; 2da: ee 0f add r30, r30 2dc: ff 1f adc r31, r31 2de: ea 5e subi r30, 0xEA ; 234 2e0: fe 4f sbci r31, 0xFE ; 254 2e2: b1 83 std Z+1, r27 ; 0x01 2e4: a0 83 st Z, r26 break; } } SREG = sregsys; 2e6: 80 91 0a 01 lds r24, 0x010A 2ea: 8f bf out 0x3f, r24 ; 63 return; } 2ec: 08 95 ret t->laps = 0; #endif for (a=0; a 2f6: 81 e0 ldi r24, 0x01 ; 1 2f8: e1 e0 ldi r30, 0x01 ; 1 2fa: f0 e0 ldi r31, 0x00 ; 0 2fc: ed cf rjmp .-38 ; 0x2d8 2fe: 83 e0 ldi r24, 0x03 ; 3 300: e3 e0 ldi r30, 0x03 ; 3 302: f0 e0 ldi r31, 0x00 ; 0 304: e9 cf rjmp .-46 ; 0x2d8 306: 82 e0 ldi r24, 0x02 ; 2 308: e2 e0 ldi r30, 0x02 ; 2 30a: f0 e0 ldi r31, 0x00 ; 0 30c: e5 cf rjmp .-54 ; 0x2d8 30e: 85 e0 ldi r24, 0x05 ; 5 310: e5 e0 ldi r30, 0x05 ; 5 312: f0 e0 ldi r31, 0x00 ; 0 314: e1 cf rjmp .-62 ; 0x2d8 316: 84 e0 ldi r24, 0x04 ; 4 318: e4 e0 ldi r30, 0x04 ; 4 31a: f0 e0 ldi r31, 0x00 ; 0 31c: dd cf rjmp .-70 ; 0x2d8 31e: 87 e0 ldi r24, 0x07 ; 7 320: e7 e0 ldi r30, 0x07 ; 7 322: f0 e0 ldi r31, 0x00 ; 0 324: d9 cf rjmp .-78 ; 0x2d8 326: 86 e0 ldi r24, 0x06 ; 6 328: e6 e0 ldi r30, 0x06 ; 6 32a: f0 e0 ldi r31, 0x00 ; 0 32c: d5 cf rjmp .-86 ; 0x2d8 32e: 8a e0 ldi r24, 0x0A ; 10 330: ea e0 ldi r30, 0x0A ; 10 332: f0 e0 ldi r31, 0x00 ; 0 334: d1 cf rjmp .-94 ; 0x2d8 336: 89 e0 ldi r24, 0x09 ; 9 338: e9 e0 ldi r30, 0x09 ; 9 33a: f0 e0 ldi r31, 0x00 ; 0 33c: cd cf rjmp .-102 ; 0x2d8 33e: 88 e0 ldi r24, 0x08 ; 8 340: e8 e0 ldi r30, 0x08 ; 8 342: f0 e0 ldi r31, 0x00 ; 0 344: c9 cf rjmp .-110 ; 0x2d8 346: 8d e0 ldi r24, 0x0D ; 13 348: ed e0 ldi r30, 0x0D ; 13 34a: f0 e0 ldi r31, 0x00 ; 0 34c: c5 cf rjmp .-118 ; 0x2d8 34e: 8c e0 ldi r24, 0x0C ; 12 350: ec e0 ldi r30, 0x0C ; 12 352: f0 e0 ldi r31, 0x00 ; 0 354: c1 cf rjmp .-126 ; 0x2d8 356: 8b e0 ldi r24, 0x0B ; 11 358: eb e0 ldi r30, 0x0B ; 11 35a: f0 e0 ldi r31, 0x00 ; 0 35c: bd cf rjmp .-134 ; 0x2d8 35e: 8e e0 ldi r24, 0x0E ; 14 360: ee e0 ldi r30, 0x0E ; 14 362: f0 e0 ldi r31, 0x00 ; 0 364: b9 cf rjmp .-142 ; 0x2d8 00000366 : //* output: TRUE(ok)/NULL(error) * //**************************************************** #ifdef TASK_USE_ANHILATE uint8_t task_anhilate(Task *t) { 366: cf 93 push r28 368: df 93 push r29 36a: fc 01 movw r30, r24 sregsys=SREG; 36c: 8f b7 in r24, 0x3f ; 63 36e: 80 93 0a 01 sts 0x010A, r24 cli(); 372: f8 94 cli #ifdef TASK_USE_SEMAPHORE //uint8_t *s = (uint8_t*) Semaphore; //uint8_t i; #endif uint8_t ID = t->ID; 374: 60 81 ld r22, Z if (ID > NUMBER || ID == 0) 376: 86 2f mov r24, r22 378: 81 50 subi r24, 0x01 ; 1 37a: 80 31 cpi r24, 0x10 ; 16 37c: 08 f0 brcs .+2 ; 0x380 37e: 6d c0 rjmp .+218 ; 0x45a SREG=sregsys; return 0; } a=ID; //reset task values if (ID == currentTask) 380: c6 2f mov r28, r22 382: d0 e0 ldi r29, 0x00 ; 0 384: 80 91 00 01 lds r24, 0x0100 388: 99 27 eor r25, r25 38a: 87 fd sbrc r24, 7 38c: 90 95 com r25 38e: c8 17 cp r28, r24 390: d9 07 cpc r29, r25 392: 09 f4 brne .+2 ; 0x396 394: 7d c0 rjmp .+250 ; 0x490 current = 0; //to avoid problems when deleting the current task tasks[a] = 0; //this deletes the task 396: fe 01 movw r30, r28 398: ee 0f add r30, r30 39a: ff 1f adc r31, r31 39c: ea 5e subi r30, 0xEA ; 234 39e: fe 4f sbci r31, 0xFE ; 254 3a0: 11 82 std Z+1, r1 ; 0x01 3a2: 10 82 st Z, r1 #ifdef TASK_USE_MEM //release task memory blocks //no reason to clear it here, because theres a clearing in memory_allocate_block() for (a=0;a 3ac: 47 c0 rjmp .+142 ; 0x43c 3ae: 50 e0 ldi r21, 0x00 ; 0 { if ((blocks+a)->owner == ID) 3b0: 73 e0 ldi r23, 0x03 ; 3 3b2: 06 c0 rjmp .+12 ; 0x3c0 tasks[a] = 0; //this deletes the task #ifdef TASK_USE_MEM //release task memory blocks //no reason to clear it here, because theres a clearing in memory_allocate_block() for (a=0;a 3be: 3e c0 rjmp .+124 ; 0x43c { if ((blocks+a)->owner == ID) 3c0: 57 9f mul r21, r23 3c2: f0 01 movw r30, r0 3c4: 11 24 eor r1, r1 3c6: e0 5f subi r30, 0xF0 ; 240 3c8: fe 4f sbci r31, 0xFE ; 254 3ca: 80 81 ld r24, Z 3cc: 86 17 cp r24, r22 3ce: 91 f7 brne .-28 ; 0x3b4 { (blocks+a)->ptr=0; 3d0: 12 82 std Z+2, r1 ; 0x02 3d2: 11 82 std Z+1, r1 ; 0x01 (blocks+a)->owner=0; 3d4: 10 82 st Z, r1 for (b=a;b<(currentBlocks-1);b++) 3d6: 25 2f mov r18, r21 3d8: 30 e0 ldi r19, 0x00 ; 0 3da: 80 91 0b 01 lds r24, 0x010B 3de: 90 e0 ldi r25, 0x00 ; 0 3e0: 01 97 sbiw r24, 0x01 ; 1 3e2: 28 17 cp r18, r24 3e4: 39 07 cpc r19, r25 3e6: 04 f5 brge .+64 ; 0x428 3e8: 45 2f mov r20, r21 blocks[b]=blocks[b+1]; 3ea: c9 01 movw r24, r18 3ec: 01 96 adiw r24, 0x01 ; 1 3ee: d9 01 movw r26, r18 3f0: aa 0f add r26, r26 3f2: bb 1f adc r27, r27 3f4: a2 0f add r26, r18 3f6: b3 1f adc r27, r19 3f8: fc 01 movw r30, r24 3fa: ee 0f add r30, r30 3fc: ff 1f adc r31, r31 3fe: e8 0f add r30, r24 400: f9 1f adc r31, r25 402: a0 5f subi r26, 0xF0 ; 240 404: be 4f sbci r27, 0xFE ; 254 406: e0 5f subi r30, 0xF0 ; 240 408: fe 4f sbci r31, 0xFE ; 254 40a: 83 e0 ldi r24, 0x03 ; 3 40c: 01 90 ld r0, Z+ 40e: 0d 92 st X+, r0 410: 81 50 subi r24, 0x01 ; 1 412: e1 f7 brne .-8 ; 0x40c { if ((blocks+a)->owner == ID) { (blocks+a)->ptr=0; (blocks+a)->owner=0; for (b=a;b<(currentBlocks-1);b++) 414: 4f 5f subi r20, 0xFF ; 255 416: 24 2f mov r18, r20 418: 30 e0 ldi r19, 0x00 ; 0 41a: 80 91 0b 01 lds r24, 0x010B 41e: 90 e0 ldi r25, 0x00 ; 0 420: 01 97 sbiw r24, 0x01 ; 1 422: 28 17 cp r18, r24 424: 39 07 cpc r19, r25 426: 0c f3 brlt .-62 ; 0x3ea blocks[b]=blocks[b+1]; currentBlocks--; 428: 80 91 0b 01 lds r24, 0x010B 42c: 81 50 subi r24, 0x01 ; 1 42e: 80 93 0b 01 sts 0x010B, r24 tasks[a] = 0; //this deletes the task #ifdef TASK_USE_MEM //release task memory blocks //no reason to clear it here, because theres a clearing in memory_allocate_block() for (a=0;a // *s = 0; // s++; // } #endif if (ID != currentTask) 43c: 80 91 00 01 lds r24, 0x0100 440: 99 27 eor r25, r25 442: 87 fd sbrc r24, 7 444: 90 95 com r25 446: c8 17 cp r28, r24 448: d9 07 cpc r29, r25 44a: 71 f0 breq .+28 ; 0x468 { //go back to parent task SREG=sregsys; 44c: 80 91 0a 01 lds r24, 0x010A 450: 8f bf out 0x3f, r24 ; 63 452: 81 e0 ldi r24, 0x01 ; 1 currentTask = -1; set_sleep_mode(SLEEP_MODE_IDLE); sei(); sleep_mode(); } } 454: df 91 pop r29 456: cf 91 pop r28 458: 08 95 ret #endif uint8_t ID = t->ID; if (ID > NUMBER || ID == 0) { SREG=sregsys; 45a: 80 91 0a 01 lds r24, 0x010A 45e: 8f bf out 0x3f, r24 ; 63 460: 80 e0 ldi r24, 0x00 ; 0 currentTask = -1; set_sleep_mode(SLEEP_MODE_IDLE); sei(); sleep_mode(); } } 462: df 91 pop r29 464: cf 91 pop r28 466: 08 95 ret return TRUE; } else { //switch to next task without going back to the deleted task if it's the parent task TIMER_REG = _BV(CS00); 468: 81 e0 ldi r24, 0x01 ; 1 46a: 85 bd out 0x25, r24 ; 37 TCNT0 = 0xFF; 46c: 8f ef ldi r24, 0xFF ; 255 46e: 86 bd out 0x26, r24 ; 38 currentTask = -1; 470: 80 93 00 01 sts 0x0100, r24 set_sleep_mode(SLEEP_MODE_IDLE); 474: 83 b7 in r24, 0x33 ; 51 476: 81 7f andi r24, 0xF1 ; 241 478: 83 bf out 0x33, r24 ; 51 sei(); 47a: 78 94 sei sleep_mode(); 47c: 83 b7 in r24, 0x33 ; 51 47e: 81 60 ori r24, 0x01 ; 1 480: 83 bf out 0x33, r24 ; 51 482: 88 95 sleep 484: 83 b7 in r24, 0x33 ; 51 486: 8e 7f andi r24, 0xFE ; 254 488: 83 bf out 0x33, r24 ; 51 } } 48a: df 91 pop r29 48c: cf 91 pop r28 48e: 08 95 ret return 0; } a=ID; //reset task values if (ID == currentTask) current = 0; //to avoid problems when deleting the current task 490: 10 92 09 01 sts 0x0109, r1 494: 10 92 08 01 sts 0x0108, r1 498: 7e cf rjmp .-260 ; 0x396 0000049a : //* output: none * //**************************************************** void task_switch() { cli(); 49a: f8 94 cli set_sleep_mode(SLEEP_MODE_IDLE); 49c: 83 b7 in r24, 0x33 ; 51 49e: 81 7f andi r24, 0xF1 ; 241 4a0: 83 bf out 0x33, r24 ; 51 TCNT0 = 0xf0; 4a2: 80 ef ldi r24, 0xF0 ; 240 4a4: 86 bd out 0x26, r24 ; 38 TIMER_REG = _BV(CS00); 4a6: 81 e0 ldi r24, 0x01 ; 1 4a8: 85 bd out 0x25, r24 ; 37 TIMER_ENABLE |= _BV(TOIE0); 4aa: ee e6 ldi r30, 0x6E ; 110 4ac: f0 e0 ldi r31, 0x00 ; 0 4ae: 80 81 ld r24, Z 4b0: 81 60 ori r24, 0x01 ; 1 4b2: 80 83 st Z, r24 sei(); 4b4: 78 94 sei sleep_mode(); 4b6: 83 b7 in r24, 0x33 ; 51 4b8: 81 60 ori r24, 0x01 ; 1 4ba: 83 bf out 0x33, r24 ; 51 4bc: 88 95 sleep 4be: 83 b7 in r24, 0x33 ; 51 4c0: 8e 7f andi r24, 0xFE ; 254 4c2: 83 bf out 0x33, r24 ; 51 } 4c4: 08 95 ret 000004c6 : //* description: set new priority for current Task * //* input: TaskPrio (low/medium/high) * //* output: new TaskPrio * //**************************************************** uint8_t taskNewPrio(TaskPrio prio) {return current->prio = prio;} 4c6: e0 91 08 01 lds r30, 0x0108 4ca: f0 91 09 01 lds r31, 0x0109 4ce: 84 83 std Z+4, r24 ; 0x04 4d0: 84 81 ldd r24, Z+4 ; 0x04 4d2: 08 95 ret 000004d4 : { while (1) { wdt_reset(); set_sleep_mode(SLEEP_MODE_IDLE); TIMER_REG = _BV(CS00); 4d4: 21 e0 ldi r18, 0x01 ; 1 TCNT0 = 0xFF; 4d6: 9f ef ldi r25, 0xFF ; 255 void idle() { while (1) { wdt_reset(); 4d8: a8 95 wdr set_sleep_mode(SLEEP_MODE_IDLE); 4da: 83 b7 in r24, 0x33 ; 51 4dc: 81 7f andi r24, 0xF1 ; 241 4de: 83 bf out 0x33, r24 ; 51 TIMER_REG = _BV(CS00); 4e0: 25 bd out 0x25, r18 ; 37 TCNT0 = 0xFF; 4e2: 96 bd out 0x26, r25 ; 38 sleep_mode(); 4e4: 83 b7 in r24, 0x33 ; 51 4e6: 81 60 ori r24, 0x01 ; 1 4e8: 83 bf out 0x33, r24 ; 51 4ea: 88 95 sleep 4ec: 83 b7 in r24, 0x33 ; 51 4ee: 8e 7f andi r24, 0xFE ; 254 4f0: 83 bf out 0x33, r24 ; 51 4f2: f2 cf rjmp .-28 ; 0x4d8 000004f4 : //* description: check if memory is available * //* input: no * //* output: number of free memory blocks * //**************************************************** uint8_t memory_get_free_blocks() {return MAXBLOCKS - currentBlocks;} 4f4: 90 91 0b 01 lds r25, 0x010B 4f8: 82 e0 ldi r24, 0x02 ; 2 4fa: 89 1b sub r24, r25 4fc: 08 95 ret 000004fe : //* output: pointer to memory block or 0 (error) * //**************************************************** void* memory_allocate_block() { sregsys = SREG; 4fe: 8f b7 in r24, 0x3f ; 63 500: 80 93 0a 01 sts 0x010A, r24 cli(); 504: f8 94 cli if (currentBlocks >= MAXBLOCKS) 506: 80 91 0b 01 lds r24, 0x010B 50a: 82 30 cpi r24, 0x02 ; 2 50c: 50 f5 brcc .+84 ; 0x562 <__stack+0x63> SREG = sregsys; return 0; } uint8_t a; char* ptr; mem_block_intern* block = (blocks+currentBlocks); 50e: 90 91 0b 01 lds r25, 0x010B 512: 83 e0 ldi r24, 0x03 ; 3 514: 98 9f mul r25, r24 516: f0 01 movw r30, r0 518: 11 24 eor r1, r1 51a: e0 5f subi r30, 0xF0 ; 240 51c: fe 4f sbci r31, 0xFE ; 254 //insert block //set a pointer to the memory block block->ptr = data+(currentBlocks*BLOCKSIZE); 51e: 80 91 0b 01 lds r24, 0x010B 522: 90 e0 ldi r25, 0x00 ; 0 524: 82 5f subi r24, 0xF2 ; 242 526: 9e 4f sbci r25, 0xFE ; 254 528: 92 83 std Z+2, r25 ; 0x02 52a: 81 83 std Z+1, r24 ; 0x01 ptr = (char*) block->ptr; 52c: a1 81 ldd r26, Z+1 ; 0x01 52e: b2 81 ldd r27, Z+2 ; 0x02 //leave if theres not enough memory if (block->ptr == 0 || (uint16_t) block->ptr > HEAPSTART) 530: 81 81 ldd r24, Z+1 ; 0x01 532: 92 81 ldd r25, Z+2 ; 0x02 534: 89 2b or r24, r25 536: a9 f0 breq .+42 ; 0x562 <__stack+0x63> 538: 81 81 ldd r24, Z+1 ; 0x01 53a: 92 81 ldd r25, Z+2 ; 0x02 53c: 80 50 subi r24, 0x00 ; 0 53e: 93 40 sbci r25, 0x03 ; 3 540: 80 f4 brcc .+32 ; 0x562 <__stack+0x63> SREG = sregsys; return 0; } //clear memory for (a=0;aowner = currentTask; 544: 80 91 00 01 lds r24, 0x0100 548: 80 83 st Z, r24 currentBlocks++; 54a: 80 91 0b 01 lds r24, 0x010B 54e: 8f 5f subi r24, 0xFF ; 255 550: 80 93 0b 01 sts 0x010B, r24 SREG = sregsys; 554: 80 91 0a 01 lds r24, 0x010A 558: 8f bf out 0x3f, r24 ; 63 //return pointer to memory block return (void*) block->ptr; 55a: 21 81 ldd r18, Z+1 ; 0x01 55c: 32 81 ldd r19, Z+2 ; 0x02 } 55e: c9 01 movw r24, r18 560: 08 95 ret block->ptr = data+(currentBlocks*BLOCKSIZE); ptr = (char*) block->ptr; //leave if theres not enough memory if (block->ptr == 0 || (uint16_t) block->ptr > HEAPSTART) { SREG = sregsys; 562: 80 91 0a 01 lds r24, 0x010A 566: 8f bf out 0x3f, r24 ; 63 568: 20 e0 ldi r18, 0x00 ; 0 56a: 30 e0 ldi r19, 0x00 ; 0 block->owner = currentTask; currentBlocks++; SREG = sregsys; //return pointer to memory block return (void*) block->ptr; } 56c: c9 01 movw r24, r18 56e: 08 95 ret 00000570 : //* input: pointer to allocated memory block * //* output: TRUE (ok) or ZERO (error) * //**************************************************** uint8_t memory_free_block(void* ptr) { 570: 9c 01 movw r18, r24 sregsys = SREG; 572: 8f b7 in r24, 0x3f ; 63 574: 80 93 0a 01 sts 0x010A, r24 cli(); 578: f8 94 cli uint8_t a,b; //search for correct memory block for (a=0;a { if ((blocks+a)->ptr == ptr) 582: 80 91 11 01 lds r24, 0x0111 586: 90 91 12 01 lds r25, 0x0112 58a: 82 17 cp r24, r18 58c: 93 07 cpc r25, r19 58e: d1 f0 breq .+52 ; 0x5c4 //re-organize memory blocks for (b=a;b<(currentBlocks-1);b++) blocks[b]=blocks[b+1]; currentBlocks--; SREG = sregsys; return TRUE; 590: 40 e0 ldi r20, 0x00 ; 0 cli(); uint8_t a,b; //search for correct memory block for (a=0;aptr == ptr) 592: 53 e0 ldi r21, 0x03 ; 3 594: 0d c0 rjmp .+26 ; 0x5b0 596: 45 9f mul r20, r21 598: f0 01 movw r30, r0 59a: 11 24 eor r1, r1 59c: df 01 movw r26, r30 59e: a0 5f subi r26, 0xF0 ; 240 5a0: be 4f sbci r27, 0xFE ; 254 5a2: 11 96 adiw r26, 0x01 ; 1 5a4: 8d 91 ld r24, X+ 5a6: 9c 91 ld r25, X 5a8: 12 97 sbiw r26, 0x02 ; 2 5aa: 82 17 cp r24, r18 5ac: 93 07 cpc r25, r19 5ae: 79 f0 breq .+30 ; 0x5ce { sregsys = SREG; cli(); uint8_t a,b; //search for correct memory block for (a=0;a currentBlocks--; SREG = sregsys; return TRUE; } } SREG = sregsys; 5ba: 80 91 0a 01 lds r24, 0x010A 5be: 8f bf out 0x3f, r24 ; 63 5c0: 80 e0 ldi r24, 0x00 ; 0 return 0; } 5c2: 08 95 ret cli(); uint8_t a,b; //search for correct memory block for (a=0;aptr == ptr) 5c4: e0 e0 ldi r30, 0x00 ; 0 5c6: f0 e0 ldi r31, 0x00 ; 0 5c8: 40 e0 ldi r20, 0x00 ; 0 5ca: a0 e1 ldi r26, 0x10 ; 16 5cc: b1 e0 ldi r27, 0x01 ; 1 { if ((blocks+a)->owner != currentTask) 5ce: 2c 91 ld r18, X 5d0: 80 91 00 01 lds r24, 0x0100 5d4: 30 e0 ldi r19, 0x00 ; 0 5d6: 99 27 eor r25, r25 5d8: 87 fd sbrc r24, 7 5da: 90 95 com r25 5dc: 28 17 cp r18, r24 5de: 39 07 cpc r19, r25 5e0: 29 f0 breq .+10 ; 0x5ec { SREG = sregsys; 5e2: 80 91 0a 01 lds r24, 0x010A 5e6: 8f bf out 0x3f, r24 ; 63 5e8: 80 e0 ldi r24, 0x00 ; 0 5ea: 08 95 ret return 0; } //if block is leased by parent task release it. //no reason to clear it here, because theres a clearing in memory_allocate_block() (blocks+a)->ptr=0; 5ec: e0 5f subi r30, 0xF0 ; 240 5ee: fe 4f sbci r31, 0xFE ; 254 5f0: 12 82 std Z+2, r1 ; 0x02 5f2: 11 82 std Z+1, r1 ; 0x01 (blocks+a)->owner=0; 5f4: 10 82 st Z, r1 //re-organize memory blocks for (b=a;b<(currentBlocks-1);b++) 5f6: 24 2f mov r18, r20 5f8: 30 e0 ldi r19, 0x00 ; 0 5fa: 80 91 0b 01 lds r24, 0x010B 5fe: 90 e0 ldi r25, 0x00 ; 0 600: 01 97 sbiw r24, 0x01 ; 1 602: 28 17 cp r18, r24 604: 39 07 cpc r19, r25 606: bc f4 brge .+46 ; 0x636 blocks[b]=blocks[b+1]; 608: c9 01 movw r24, r18 60a: 01 96 adiw r24, 0x01 ; 1 60c: d9 01 movw r26, r18 60e: aa 0f add r26, r26 610: bb 1f adc r27, r27 612: a2 0f add r26, r18 614: b3 1f adc r27, r19 616: fc 01 movw r30, r24 618: ee 0f add r30, r30 61a: ff 1f adc r31, r31 61c: e8 0f add r30, r24 61e: f9 1f adc r31, r25 620: a0 5f subi r26, 0xF0 ; 240 622: be 4f sbci r27, 0xFE ; 254 624: e0 5f subi r30, 0xF0 ; 240 626: fe 4f sbci r31, 0xFE ; 254 628: 83 e0 ldi r24, 0x03 ; 3 62a: 01 90 ld r0, Z+ 62c: 0d 92 st X+, r0 62e: 81 50 subi r24, 0x01 ; 1 630: e1 f7 brne .-8 ; 0x62a //if block is leased by parent task release it. //no reason to clear it here, because theres a clearing in memory_allocate_block() (blocks+a)->ptr=0; (blocks+a)->owner=0; //re-organize memory blocks for (b=a;b<(currentBlocks-1);b++) 632: 4f 5f subi r20, 0xFF ; 255 634: e0 cf rjmp .-64 ; 0x5f6 blocks[b]=blocks[b+1]; currentBlocks--; 636: 80 91 0b 01 lds r24, 0x010B 63a: 81 50 subi r24, 0x01 ; 1 63c: 80 93 0b 01 sts 0x010B, r24 SREG = sregsys; 640: 80 91 0a 01 lds r24, 0x010A 644: 8f bf out 0x3f, r24 ; 63 646: 81 e0 ldi r24, 0x01 ; 1 648: 08 95 ret 0000064a : //* input: Queue *qp: Pointer to queue * //* output: free places in the queue * //**************************************************** uint8_t queue_exists(Queue *qp) { 64a: fc 01 movw r30, r24 if (qp->queueDepth) 64c: 81 81 ldd r24, Z+1 ; 0x01 64e: 81 11 cpse r24, r1 650: 81 e0 ldi r24, 0x01 ; 1 return TRUE; return 0; } 652: 08 95 ret 00000654 : //* input: Queue *qp: Pointer to queue * //* output: maximum number of messages in the queue * //**************************************************** uint8_t queue_get_maximum_size(Queue *qp) { 654: fc 01 movw r30, r24 return qp->queueDepth; 656: 81 81 ldd r24, Z+1 ; 0x01 } 658: 08 95 ret 0000065a : //* input: Pointer to queue * //* output: free places in the queue * //**************************************************** uint8_t queue_get_free_size(Queue *qp) { 65a: fc 01 movw r30, r24 return qp->queueDepth - qp->number; 65c: 81 81 ldd r24, Z+1 ; 0x01 65e: 92 81 ldd r25, Z+2 ; 0x02 } 660: 89 1b sub r24, r25 662: 08 95 ret 00000664 : //* input: Queue *qp: Pointer to queue * //* output: number of messages in the queue * //**************************************************** uint8_t queue_get_mumber_of_messages(Queue *qp) { 664: fc 01 movw r30, r24 return qp->number; 666: 82 81 ldd r24, Z+2 ; 0x02 } 668: 08 95 ret 0000066a : //* input: Queue *qp: Pointer to queue * //* output: TRUE (new message), ZERO (error) * //**************************************************** uint8_t queue_wait_for_message(Queue *qp) { 66a: fc 01 movw r30, r24 //enable multitasking to avoid a deadrun wdt_enable(WDTO_2S); 66c: 2f e0 ldi r18, 0x0F ; 15 66e: 88 e1 ldi r24, 0x18 ; 24 670: 90 e0 ldi r25, 0x00 ; 0 672: 0f b6 in r0, 0x3f ; 63 674: f8 94 cli 676: a8 95 wdr 678: 80 93 60 00 sts 0x0060, r24 67c: 0f be out 0x3f, r0 ; 63 67e: 20 93 60 00 sts 0x0060, r18 TIMER_ENABLE |= _BV(TOIE0); 682: 80 91 6e 00 lds r24, 0x006E 686: 81 60 ori r24, 0x01 ; 1 688: 80 93 6e 00 sts 0x006E, r24 sei(); 68c: 78 94 sei if (qp->queueDepth == 0) 68e: 81 81 ldd r24, Z+1 ; 0x01 690: 88 23 and r24, r24 692: 49 f0 breq .+18 ; 0x6a6 return 0; while (qp->number == 0) 694: 82 81 ldd r24, Z+2 ; 0x02 696: 88 23 and r24, r24 698: 29 f4 brne .+10 ; 0x6a4 TCNT0=0xFF; 69a: 9f ef ldi r25, 0xFF ; 255 69c: 96 bd out 0x26, r25 ; 38 wdt_enable(WDTO_2S); TIMER_ENABLE |= _BV(TOIE0); sei(); if (qp->queueDepth == 0) return 0; while (qp->number == 0) 69e: 82 81 ldd r24, Z+2 ; 0x02 6a0: 88 23 and r24, r24 6a2: e1 f3 breq .-8 ; 0x69c 6a4: 81 e0 ldi r24, 0x01 ; 1 TCNT0=0xFF; return TRUE; } 6a6: 08 95 ret 000006a8 : //* Works only with 1-byte-item Queues! * //* * //*********************************************************************** unsigned char queue_read_byte(Queue *qp, uint8_t position, uint8_t delete_message) { 6a8: cf 93 push r28 6aa: df 93 push r29 6ac: ec 01 movw r28, r24 sregsys = SREG; 6ae: 8f b7 in r24, 0x3f ; 63 6b0: 80 93 0a 01 sts 0x010A, r24 cli(); 6b4: f8 94 cli uint8_t i; unsigned char tempmsg; if (qp->number == 0 || qp->number <= position || qp->item_size != 1) 6b6: 8a 81 ldd r24, Y+2 ; 0x02 6b8: 88 23 and r24, r24 6ba: 31 f0 breq .+12 ; 0x6c8 6bc: 8a 81 ldd r24, Y+2 ; 0x02 6be: 68 17 cp r22, r24 6c0: 18 f4 brcc .+6 ; 0x6c8 6c2: 88 81 ld r24, Y 6c4: 81 30 cpi r24, 0x01 ; 1 6c6: 31 f0 breq .+12 ; 0x6d4 { SREG = sregsys; 6c8: 80 91 0a 01 lds r24, 0x010A 6cc: 8f bf out 0x3f, r24 ; 63 qp->message[i] = qp->message[i+1]; qp->number--; } SREG = sregsys; return tempmsg; } 6ce: df 91 pop r29 6d0: cf 91 pop r28 6d2: 08 95 ret { SREG = sregsys; return; } //read message tempmsg = qp->message[position]; 6d4: ed 81 ldd r30, Y+5 ; 0x05 6d6: fe 81 ldd r31, Y+6 ; 0x06 6d8: 26 2f mov r18, r22 6da: 30 e0 ldi r19, 0x00 ; 0 6dc: e2 0f add r30, r18 6de: f3 1f adc r31, r19 6e0: 50 81 ld r21, Z if (delete_message) 6e2: 44 23 and r20, r20 6e4: f1 f0 breq .+60 ; 0x722 { //re-organize message queue (FIFO) for (i=position;i<(qp->number)-1;i++) 6e6: 8a 81 ldd r24, Y+2 ; 0x02 6e8: 90 e0 ldi r25, 0x00 ; 0 6ea: 01 97 sbiw r24, 0x01 ; 1 6ec: 28 17 cp r18, r24 6ee: 39 07 cpc r19, r25 6f0: ac f4 brge .+42 ; 0x71c qp->message[i] = qp->message[i+1]; 6f2: ad 81 ldd r26, Y+5 ; 0x05 6f4: be 81 ldd r27, Y+6 ; 0x06 6f6: a2 0f add r26, r18 6f8: b3 1f adc r27, r19 6fa: ed 81 ldd r30, Y+5 ; 0x05 6fc: fe 81 ldd r31, Y+6 ; 0x06 6fe: 2f 5f subi r18, 0xFF ; 255 700: 3f 4f sbci r19, 0xFF ; 255 702: e2 0f add r30, r18 704: f3 1f adc r31, r19 706: 80 81 ld r24, Z 708: 8c 93 st X, r24 //read message tempmsg = qp->message[position]; if (delete_message) { //re-organize message queue (FIFO) for (i=position;i<(qp->number)-1;i++) 70a: 6f 5f subi r22, 0xFF ; 255 70c: 8a 81 ldd r24, Y+2 ; 0x02 70e: 26 2f mov r18, r22 710: 30 e0 ldi r19, 0x00 ; 0 712: 90 e0 ldi r25, 0x00 ; 0 714: 01 97 sbiw r24, 0x01 ; 1 716: 28 17 cp r18, r24 718: 39 07 cpc r19, r25 71a: 5c f3 brlt .-42 ; 0x6f2 qp->message[i] = qp->message[i+1]; qp->number--; 71c: 8a 81 ldd r24, Y+2 ; 0x02 71e: 81 50 subi r24, 0x01 ; 1 720: 8a 83 std Y+2, r24 ; 0x02 } SREG = sregsys; 722: 80 91 0a 01 lds r24, 0x010A 726: 8f bf out 0x3f, r24 ; 63 728: 85 2f mov r24, r21 72a: d1 cf rjmp .-94 ; 0x6ce 0000072c : //* uint8_t delete_message: 1=delete message after reading * //* output: ZERO (error), TRUE (ok) * //******************************************************************************* uint8_t queue_read_item(Queue *qp, unsigned char* targetpointer, uint8_t position, uint8_t delete_message) { 72c: cf 92 push r12 72e: df 92 push r13 730: ef 92 push r14 732: ff 92 push r15 734: 0f 93 push r16 736: 1f 93 push r17 738: cf 93 push r28 73a: df 93 push r29 73c: ec 01 movw r28, r24 73e: 8b 01 movw r16, r22 740: 94 2f mov r25, r20 742: e2 2e mov r14, r18 sregsys = SREG; 744: 8f b7 in r24, 0x3f ; 63 746: 80 93 0a 01 sts 0x010A, r24 cli(); 74a: f8 94 cli uint8_t i,j; position = position * qp->item_size; // get correct message for the given entry. 74c: 48 81 ld r20, Y if (qp->number == 0 || qp->number <= position || targetpointer == 0) 74e: 8a 81 ldd r24, Y+2 ; 0x02 750: 88 23 and r24, r24 752: 09 f4 brne .+2 ; 0x756 754: 57 c0 rjmp .+174 ; 0x804 uint8_t queue_read_item(Queue *qp, unsigned char* targetpointer, uint8_t position, uint8_t delete_message) { sregsys = SREG; cli(); uint8_t i,j; position = position * qp->item_size; // get correct message for the given entry. 756: 94 9f mul r25, r20 758: f0 2c mov r15, r0 75a: 11 24 eor r1, r1 if (qp->number == 0 || qp->number <= position || targetpointer == 0) 75c: 8a 81 ldd r24, Y+2 ; 0x02 75e: f8 16 cp r15, r24 760: 08 f0 brcs .+2 ; 0x764 762: 50 c0 rjmp .+160 ; 0x804 764: 61 15 cp r22, r1 766: 71 05 cpc r23, r1 768: 09 f4 brne .+2 ; 0x76c 76a: 4c c0 rjmp .+152 ; 0x804 { SREG = sregsys; return 0; } //read messages for (i=position;i<(position+qp->item_size);i++) 76c: 6f 2d mov r22, r15 76e: 70 e0 ldi r23, 0x00 ; 0 770: 88 81 ld r24, Y 772: 9b 01 movw r18, r22 774: 28 0f add r18, r24 776: 31 1d adc r19, r1 778: 62 17 cp r22, r18 77a: 73 07 cpc r23, r19 77c: f4 f5 brge .+124 ; 0x7fa uint8_t i,j; position = position * qp->item_size; // get correct message for the given entry. if (qp->number == 0 || qp->number <= position || targetpointer == 0) { SREG = sregsys; return 0; 77e: 4f 2d mov r20, r15 780: db 01 movw r26, r22 782: cb 01 movw r24, r22 784: d8 2e mov r13, r24 786: c9 2e mov r12, r25 } //read messages for (i=position;i<(position+qp->item_size);i++) { if (delete_message) 788: ee 20 and r14, r14 78a: 09 f4 brne .+2 ; 0x78e 78c: 48 c0 rjmp .+144 ; 0x81e { *(targetpointer+(i-position)) = qp->message[position]; 78e: ed 81 ldd r30, Y+5 ; 0x05 790: fe 81 ldd r31, Y+6 ; 0x06 792: e6 0f add r30, r22 794: f7 1f adc r31, r23 796: 80 81 ld r24, Z 798: a6 1b sub r26, r22 79a: b7 0b sbc r27, r23 79c: a0 0f add r26, r16 79e: b1 1f adc r27, r17 7a0: 8c 93 st X, r24 //re-organize message queue (FIFO) for (j=position;j<(qp->number)-1;j++) 7a2: 8a 81 ldd r24, Y+2 ; 0x02 7a4: 90 e0 ldi r25, 0x00 ; 0 7a6: 01 97 sbiw r24, 0x01 ; 1 7a8: 68 17 cp r22, r24 7aa: 79 07 cpc r23, r25 7ac: cc f4 brge .+50 ; 0x7e0 7ae: 5f 2d mov r21, r15 7b0: 8d 2d mov r24, r13 7b2: 9c 2d mov r25, r12 7b4: 9c 01 movw r18, r24 qp->message[j] = qp->message[j+1]; 7b6: ad 81 ldd r26, Y+5 ; 0x05 7b8: be 81 ldd r27, Y+6 ; 0x06 7ba: a2 0f add r26, r18 7bc: b3 1f adc r27, r19 7be: ed 81 ldd r30, Y+5 ; 0x05 7c0: fe 81 ldd r31, Y+6 ; 0x06 7c2: 2f 5f subi r18, 0xFF ; 255 7c4: 3f 4f sbci r19, 0xFF ; 255 7c6: e2 0f add r30, r18 7c8: f3 1f adc r31, r19 7ca: 80 81 ld r24, Z 7cc: 8c 93 st X, r24 { if (delete_message) { *(targetpointer+(i-position)) = qp->message[position]; //re-organize message queue (FIFO) for (j=position;j<(qp->number)-1;j++) 7ce: 5f 5f subi r21, 0xFF ; 255 7d0: 8a 81 ldd r24, Y+2 ; 0x02 7d2: 25 2f mov r18, r21 7d4: 30 e0 ldi r19, 0x00 ; 0 7d6: 90 e0 ldi r25, 0x00 ; 0 7d8: 01 97 sbiw r24, 0x01 ; 1 7da: 28 17 cp r18, r24 7dc: 39 07 cpc r19, r25 7de: 5c f3 brlt .-42 ; 0x7b6 qp->message[j] = qp->message[j+1]; qp->number--; 7e0: 8a 81 ldd r24, Y+2 ; 0x02 7e2: 81 50 subi r24, 0x01 ; 1 7e4: 8a 83 std Y+2, r24 ; 0x02 { SREG = sregsys; return 0; } //read messages for (i=position;i<(position+qp->item_size);i++) 7e6: 4f 5f subi r20, 0xFF ; 255 7e8: a4 2f mov r26, r20 7ea: b0 e0 ldi r27, 0x00 ; 0 7ec: 88 81 ld r24, Y 7ee: 9b 01 movw r18, r22 7f0: 28 0f add r18, r24 7f2: 31 1d adc r19, r1 7f4: a2 17 cp r26, r18 7f6: b3 07 cpc r27, r19 7f8: 3c f2 brlt .-114 ; 0x788 qp->number--; } else *(targetpointer+(i-position)) = qp->message[i]; } SREG = sregsys; 7fa: 80 91 0a 01 lds r24, 0x010A 7fe: 8f bf out 0x3f, r24 ; 63 800: 81 e0 ldi r24, 0x01 ; 1 802: 04 c0 rjmp .+8 ; 0x80c cli(); uint8_t i,j; position = position * qp->item_size; // get correct message for the given entry. if (qp->number == 0 || qp->number <= position || targetpointer == 0) { SREG = sregsys; 804: 80 91 0a 01 lds r24, 0x010A 808: 8f bf out 0x3f, r24 ; 63 80a: 80 e0 ldi r24, 0x00 ; 0 else *(targetpointer+(i-position)) = qp->message[i]; } SREG = sregsys; return TRUE; } 80c: df 91 pop r29 80e: cf 91 pop r28 810: 1f 91 pop r17 812: 0f 91 pop r16 814: ff 90 pop r15 816: ef 90 pop r14 818: df 90 pop r13 81a: cf 90 pop r12 81c: 08 95 ret for (j=position;j<(qp->number)-1;j++) qp->message[j] = qp->message[j+1]; qp->number--; } else *(targetpointer+(i-position)) = qp->message[i]; 81e: ed 81 ldd r30, Y+5 ; 0x05 820: fe 81 ldd r31, Y+6 ; 0x06 822: e4 0f add r30, r20 824: f1 1d adc r31, r1 826: 80 81 ld r24, Z 828: a6 1b sub r26, r22 82a: b7 0b sbc r27, r23 82c: a0 0f add r26, r16 82e: b1 1f adc r27, r17 830: 8c 93 st X, r24 832: d9 cf rjmp .-78 ; 0x7e6 00000834 : //* input: Queue *qp: Pointer to queue * //* output: Pointer * //*********************************************** void* queue_read_pointer (Queue *qp) { 834: fc 01 movw r30, r24 return (void*) qp->ptr; 836: 23 81 ldd r18, Z+3 ; 0x03 838: 34 81 ldd r19, Z+4 ; 0x04 } 83a: c9 01 movw r24, r18 83c: 08 95 ret 0000083e : //* Works only with 1-byte-item Queues! * //* * //**************************************************** uint8_t queue_write_byte (Queue *qp, unsigned char message) { 83e: dc 01 movw r26, r24 sregsys = SREG; 840: 8f b7 in r24, 0x3f ; 63 842: 80 93 0a 01 sts 0x010A, r24 cli(); 846: f8 94 cli uint8_t mlen = qp->number; 848: 12 96 adiw r26, 0x02 ; 2 84a: 2c 91 ld r18, X 84c: 12 97 sbiw r26, 0x02 ; 2 if (mlen > (qp->queueDepth - 1) || qp->item_size != 1) 84e: 11 96 adiw r26, 0x01 ; 1 850: 8c 91 ld r24, X 852: 11 97 sbiw r26, 0x01 ; 1 854: 90 e0 ldi r25, 0x00 ; 0 856: 30 e0 ldi r19, 0x00 ; 0 858: 28 17 cp r18, r24 85a: 39 07 cpc r19, r25 85c: 1c f4 brge .+6 ; 0x864 85e: 8c 91 ld r24, X 860: 81 30 cpi r24, 0x01 ; 1 862: 29 f0 breq .+10 ; 0x86e { SREG = sregsys; 864: 80 91 0a 01 lds r24, 0x010A 868: 8f bf out 0x3f, r24 ; 63 86a: 80 e0 ldi r24, 0x00 ; 0 86c: 08 95 ret return 0; } //insert message qp->message[mlen]=message; 86e: 15 96 adiw r26, 0x05 ; 5 870: ed 91 ld r30, X+ 872: fc 91 ld r31, X 874: 16 97 sbiw r26, 0x06 ; 6 876: e2 0f add r30, r18 878: f3 1f adc r31, r19 87a: 60 83 st Z, r22 qp->number++; 87c: 12 96 adiw r26, 0x02 ; 2 87e: 8c 91 ld r24, X 880: 12 97 sbiw r26, 0x02 ; 2 882: 8f 5f subi r24, 0xFF ; 255 884: 12 96 adiw r26, 0x02 ; 2 886: 8c 93 st X, r24 SREG = sregsys; 888: 80 91 0a 01 lds r24, 0x010A 88c: 8f bf out 0x3f, r24 ; 63 88e: 81 e0 ldi r24, 0x01 ; 1 return TRUE; } 890: 08 95 ret 00000892 : //* * //* output: TRUE(ok), ZERO (error) * //******************************************************************* uint8_t queue_write_item (Queue *qp, void* startpointer) { 892: 1f 93 push r17 894: cf 93 push r28 896: df 93 push r29 898: ec 01 movw r28, r24 89a: 16 2f mov r17, r22 sregsys = SREG; 89c: 8f b7 in r24, 0x3f ; 63 89e: 80 93 0a 01 sts 0x010A, r24 cli(); 8a2: f8 94 cli uint8_t mlen = qp->number,i=0; 8a4: 2a 81 ldd r18, Y+2 ; 0x02 uint8_t length = qp->item_size; 8a6: 68 81 ld r22, Y if (mlen + length > qp->queueDepth) 8a8: 89 81 ldd r24, Y+1 ; 0x01 8aa: 42 2f mov r20, r18 8ac: 50 e0 ldi r21, 0x00 ; 0 8ae: 9a 01 movw r18, r20 8b0: 26 0f add r18, r22 8b2: 31 1d adc r19, r1 8b4: 90 e0 ldi r25, 0x00 ; 0 8b6: 82 17 cp r24, r18 8b8: 93 07 cpc r25, r19 8ba: ec f0 brlt .+58 ; 0x8f6 { SREG = sregsys; return 0; } //insert message as 1-byte chunks for (i=0;i uint8_t mlen = qp->number,i=0; uint8_t length = qp->item_size; if (mlen + length > qp->queueDepth) { SREG = sregsys; return 0; 8c0: 81 2f mov r24, r17 8c2: 97 2f mov r25, r23 8c4: 9c 01 movw r18, r24 8c6: d9 01 movw r26, r18 } //insert message as 1-byte chunks for (i=0;imessage[mlen+i]=*((unsigned char*)startpointer++); 8c8: ed 81 ldd r30, Y+5 ; 0x05 8ca: fe 81 ldd r31, Y+6 ; 0x06 8cc: e4 0f add r30, r20 8ce: f5 1f adc r31, r21 8d0: 8d 91 ld r24, X+ 8d2: 80 83 st Z, r24 qp->number++; 8d4: 8a 81 ldd r24, Y+2 ; 0x02 8d6: 8f 5f subi r24, 0xFF ; 255 8d8: 8a 83 std Y+2, r24 ; 0x02 8da: 4f 5f subi r20, 0xFF ; 255 8dc: 5f 4f sbci r21, 0xFF ; 255 { SREG = sregsys; return 0; } //insert message as 1-byte chunks for (i=0;i { qp->message[mlen+i]=*((unsigned char*)startpointer++); qp->number++; } SREG = sregsys; 8e6: 80 91 0a 01 lds r24, 0x010A 8ea: 8f bf out 0x3f, r24 ; 63 8ec: 81 e0 ldi r24, 0x01 ; 1 return TRUE; } 8ee: df 91 pop r29 8f0: cf 91 pop r28 8f2: 1f 91 pop r17 8f4: 08 95 ret cli(); uint8_t mlen = qp->number,i=0; uint8_t length = qp->item_size; if (mlen + length > qp->queueDepth) { SREG = sregsys; 8f6: 80 91 0a 01 lds r24, 0x010A 8fa: 8f bf out 0x3f, r24 ; 63 8fc: 80 e0 ldi r24, 0x00 ; 0 qp->message[mlen+i]=*((unsigned char*)startpointer++); qp->number++; } SREG = sregsys; return TRUE; } 8fe: df 91 pop r29 900: cf 91 pop r28 902: 1f 91 pop r17 904: 08 95 ret 00000906 : //* void* Pointer: pointer to begin of word * //* output: TRUE(ok), ZERO (error) * //******************************************************* uint8_t queue_write_pointer (Queue *qp, void* pointer) { 906: fc 01 movw r30, r24 sregsys = SREG; 908: 8f b7 in r24, 0x3f ; 63 90a: 80 93 0a 01 sts 0x010A, r24 cli(); 90e: f8 94 cli if (pointer == 0) 910: 61 15 cp r22, r1 912: 71 05 cpc r23, r1 914: 39 f0 breq .+14 ; 0x924 { SREG = sregsys; return 0; } //insert pointer qp->ptr = pointer; 916: 74 83 std Z+4, r23 ; 0x04 918: 63 83 std Z+3, r22 ; 0x03 SREG = sregsys; 91a: 80 91 0a 01 lds r24, 0x010A 91e: 8f bf out 0x3f, r24 ; 63 920: 81 e0 ldi r24, 0x01 ; 1 return TRUE; } 922: 08 95 ret { sregsys = SREG; cli(); if (pointer == 0) { SREG = sregsys; 924: 80 91 0a 01 lds r24, 0x010A 928: 8f bf out 0x3f, r24 ; 63 92a: 80 e0 ldi r24, 0x00 ; 0 92c: 08 95 ret 0000092e : //* input: Queue *qp: Pointer to queue * //* output: TRUE(ok), ZERO(error) * //**************************************************** uint8_t queue_anhilate(Queue *qp) { 92e: cf 93 push r28 930: df 93 push r29 932: ec 01 movw r28, r24 sregsys = SREG; 934: 8f b7 in r24, 0x3f ; 63 936: 80 93 0a 01 sts 0x010A, r24 cli(); 93a: f8 94 cli if (qp->message == 0) 93c: 8d 81 ldd r24, Y+5 ; 0x05 93e: 9e 81 ldd r25, Y+6 ; 0x06 940: 89 2b or r24, r25 942: 79 f0 breq .+30 ; 0x962 { SREG = sregsys; return 0; } //free memory and reset other values free ((void*) qp->message); 944: 8d 81 ldd r24, Y+5 ; 0x05 946: 9e 81 ldd r25, Y+6 ; 0x06 948: 0e 94 72 0c call 0x18e4 ; 0x18e4 qp->message = 0; 94c: 1e 82 std Y+6, r1 ; 0x06 94e: 1d 82 std Y+5, r1 ; 0x05 qp->number = 0; 950: 1a 82 std Y+2, r1 ; 0x02 qp->queueDepth = 0; 952: 19 82 std Y+1, r1 ; 0x01 SREG = sregsys; 954: 80 91 0a 01 lds r24, 0x010A 958: 8f bf out 0x3f, r24 ; 63 95a: 81 e0 ldi r24, 0x01 ; 1 return TRUE; } 95c: df 91 pop r29 95e: cf 91 pop r28 960: 08 95 ret { sregsys = SREG; cli(); if (qp->message == 0) { SREG = sregsys; 962: 80 91 0a 01 lds r24, 0x010A 966: 8f bf out 0x3f, r24 ; 63 968: 80 e0 ldi r24, 0x00 ; 0 qp->message = 0; qp->number = 0; qp->queueDepth = 0; SREG = sregsys; return TRUE; } 96a: df 91 pop r29 96c: cf 91 pop r28 96e: 08 95 ret 00000970 : //* input: Queue *qp: Pointer to queue, MessageQueueDepth: depth in byte* //* output: TRUE(ok), ZERO(error) * //*********************************************************************** uint8_t queue_init(Queue *qp, uint8_t MessageQueueDepth, uint8_t item_size) { 970: 0f 93 push r16 972: 1f 93 push r17 974: cf 93 push r28 976: df 93 push r29 978: ec 01 movw r28, r24 97a: 16 2f mov r17, r22 97c: 04 2f mov r16, r20 sregsys = SREG; 97e: 8f b7 in r24, 0x3f ; 63 980: 80 93 0a 01 sts 0x010A, r24 cli(); 984: f8 94 cli if (MessageQueueDepth == 0 || item_size == 0 || MessageQueueDepth > MAXQUEUEDEPTH) 986: 66 23 and r22, r22 988: 21 f0 breq .+8 ; 0x992 98a: 44 23 and r20, r20 98c: 11 f0 breq .+4 ; 0x992 98e: 63 30 cpi r22, 0x03 ; 3 990: 48 f0 brcs .+18 ; 0x9a4 //allocate memory for queue dynamically qp->message = (unsigned char*) malloc (MessageQueueDepth*item_size); if (qp->message == 0 || (uint16_t) qp->message > SP) { qp->queueDepth = 0; SREG = sregsys; 992: 80 91 0a 01 lds r24, 0x010A 996: 8f bf out 0x3f, r24 ; 63 998: 80 e0 ldi r24, 0x00 ; 0 qp->queueDepth = MessageQueueDepth*item_size; qp->item_size = item_size; qp->ptr = 0; SREG = sregsys; return TRUE; } 99a: df 91 pop r29 99c: cf 91 pop r28 99e: 1f 91 pop r17 9a0: 0f 91 pop r16 9a2: 08 95 ret { SREG = sregsys; return 0; } //allocate memory for queue dynamically qp->message = (unsigned char*) malloc (MessageQueueDepth*item_size); 9a4: 46 9f mul r20, r22 9a6: c0 01 movw r24, r0 9a8: 11 24 eor r1, r1 9aa: 0e 94 c5 0b call 0x178a ; 0x178a 9ae: 9e 83 std Y+6, r25 ; 0x06 9b0: 8d 83 std Y+5, r24 ; 0x05 if (qp->message == 0 || (uint16_t) qp->message > SP) 9b2: 8d 81 ldd r24, Y+5 ; 0x05 9b4: 9e 81 ldd r25, Y+6 ; 0x06 9b6: 89 2b or r24, r25 9b8: 99 f0 breq .+38 ; 0x9e0 9ba: 2d 81 ldd r18, Y+5 ; 0x05 9bc: 3e 81 ldd r19, Y+6 ; 0x06 9be: 8d b7 in r24, 0x3d ; 61 9c0: 9e b7 in r25, 0x3e ; 62 9c2: 82 17 cp r24, r18 9c4: 93 07 cpc r25, r19 9c6: 60 f0 brcs .+24 ; 0x9e0 { qp->queueDepth = 0; SREG = sregsys; return 0; } qp->queueDepth = MessageQueueDepth*item_size; 9c8: 01 9f mul r16, r17 9ca: 80 2d mov r24, r0 9cc: 11 24 eor r1, r1 9ce: 89 83 std Y+1, r24 ; 0x01 qp->item_size = item_size; 9d0: 08 83 st Y, r16 qp->ptr = 0; 9d2: 1c 82 std Y+4, r1 ; 0x04 9d4: 1b 82 std Y+3, r1 ; 0x03 SREG = sregsys; 9d6: 80 91 0a 01 lds r24, 0x010A 9da: 8f bf out 0x3f, r24 ; 63 9dc: 81 e0 ldi r24, 0x01 ; 1 9de: dd cf rjmp .-70 ; 0x99a } //allocate memory for queue dynamically qp->message = (unsigned char*) malloc (MessageQueueDepth*item_size); if (qp->message == 0 || (uint16_t) qp->message > SP) { qp->queueDepth = 0; 9e0: 19 82 std Y+1, r1 ; 0x01 9e2: d7 cf rjmp .-82 ; 0x992 000009e4 : } } //this calculates the time void time_calc() { 9e4: ef 92 push r14 9e6: ff 92 push r15 9e8: 0f 93 push r16 9ea: 1f 93 push r17 9ec: cf 93 push r28 9ee: df 93 push r29 //**************************************************** uint8_t queue_wait_for_message(Queue *qp) { //enable multitasking to avoid a deadrun wdt_enable(WDTO_2S); 9f0: c8 e1 ldi r28, 0x18 ; 24 9f2: d0 e0 ldi r29, 0x00 ; 0 9f4: ff e0 ldi r31, 0x0F ; 15 9f6: ff 2e mov r15, r31 TIMER_ENABLE |= _BV(TOIE0); sei(); if (qp->queueDepth == 0) return 0; while (qp->number == 0) TCNT0=0xFF; 9f8: 1f ef ldi r17, 0xFF ; 255 m = 0; } // else it must be a new second else { TASK_ENTER_CRITICAL; 9fa: e8 e1 ldi r30, 0x18 ; 24 9fc: ee 2e mov r14, r30 //**************************************************** uint8_t queue_wait_for_message(Queue *qp) { //enable multitasking to avoid a deadrun wdt_enable(WDTO_2S); 9fe: 0f b6 in r0, 0x3f ; 63 a00: f8 94 cli a02: a8 95 wdr a04: c0 93 60 00 sts 0x0060, r28 a08: 0f be out 0x3f, r0 ; 63 a0a: f0 92 60 00 sts 0x0060, r15 TIMER_ENABLE |= _BV(TOIE0); a0e: 80 91 6e 00 lds r24, 0x006E a12: 81 60 ori r24, 0x01 ; 1 a14: 80 93 6e 00 sts 0x006E, r24 sei(); a18: 78 94 sei if (qp->queueDepth == 0) a1a: 80 91 37 01 lds r24, 0x0137 a1e: 88 23 and r24, r24 a20: 11 f4 brne .+4 ; 0xa26 a22: 05 c0 rjmp .+10 ; 0xa2e return 0; while (qp->number == 0) TCNT0=0xFF; a24: 16 bd out 0x26, r17 ; 38 wdt_enable(WDTO_2S); TIMER_ENABLE |= _BV(TOIE0); sei(); if (qp->queueDepth == 0) return 0; while (qp->number == 0) a26: 80 91 38 01 lds r24, 0x0138 a2a: 88 23 and r24, r24 a2c: d9 f3 breq .-10 ; 0xa24 //* * //*********************************************************************** unsigned char queue_read_byte(Queue *qp, uint8_t position, uint8_t delete_message) { sregsys = SREG; a2e: 8f b7 in r24, 0x3f ; 63 a30: 80 93 0a 01 sts 0x010A, r24 cli(); a34: f8 94 cli uint8_t i; unsigned char tempmsg; if (qp->number == 0 || qp->number <= position || qp->item_size != 1) a36: 80 91 38 01 lds r24, 0x0138 a3a: 88 23 and r24, r24 a3c: 49 f0 breq .+18 ; 0xa50 a3e: 80 91 38 01 lds r24, 0x0138 a42: 88 23 and r24, r24 a44: 29 f0 breq .+10 ; 0xa50 a46: 80 91 36 01 lds r24, 0x0136 a4a: 81 30 cpi r24, 0x01 ; 1 a4c: 09 f4 brne .+2 ; 0xa50 a4e: 7c c0 rjmp .+248 ; 0xb48 //re-organize message queue (FIFO) for (i=position;i<(qp->number)-1;i++) qp->message[i] = qp->message[i+1]; qp->number--; } SREG = sregsys; a50: 80 91 0a 01 lds r24, 0x010A a54: 8f bf out 0x3f, r24 ; 63 { //wait for message. A message appears every second or when a button is pressed. queue_wait_for_message(&time_calc_queue); calc_msg = queue_read_byte(&time_calc_queue,0,1); // if button 1 is pressed increase hours if (calc_msg == 1) a56: 01 30 cpi r16, 0x01 ; 1 a58: 09 f4 brne .+2 ; 0xa5c a5a: 5f c0 rjmp .+190 ; 0xb1a h++; else h = 0; } // if button 2 is pressed increase minutes else if (calc_msg == 2) a5c: 02 30 cpi r16, 0x02 ; 2 a5e: 09 f4 brne .+2 ; 0xa62 a60: 60 c0 rjmp .+192 ; 0xb22 m = 0; } // else it must be a new second else { TASK_ENTER_CRITICAL; a62: 8f b7 in r24, 0x3f ; 63 a64: 80 93 0d 01 sts 0x010D, r24 a68: 0f b6 in r0, 0x3f ; 63 a6a: f8 94 cli a6c: e0 92 60 00 sts 0x0060, r14 a70: 10 92 60 00 sts 0x0060, r1 a74: 0f be out 0x3f, r0 ; 63 a76: f8 94 cli s++; a78: 6f 5f subi r22, 0xFF ; 255 if (s == 60) a7a: 6c 33 cpi r22, 0x3C ; 60 a7c: 09 f4 brne .+2 ; 0xa80 a7e: 57 c0 rjmp .+174 ; 0xb2e h++; if (h == 24) h = 0; } } TASK_LEAVE_CRITICAL; a80: 78 94 sei a82: 0f b6 in r0, 0x3f ; 63 a84: f8 94 cli a86: a8 95 wdr a88: c0 93 60 00 sts 0x0060, r28 a8c: 0f be out 0x3f, r0 ; 63 a8e: f0 92 60 00 sts 0x0060, r15 a92: 80 91 0d 01 lds r24, 0x010D a96: 8f bf out 0x3f, r24 ; 63 //* * //**************************************************** uint8_t queue_write_byte (Queue *qp, unsigned char message) { sregsys = SREG; a98: 8f b7 in r24, 0x3f ; 63 a9a: 80 93 0a 01 sts 0x010A, r24 cli(); a9e: f8 94 cli uint8_t mlen = qp->number; aa0: 20 91 15 02 lds r18, 0x0215 if (mlen > (qp->queueDepth - 1) || qp->item_size != 1) aa4: 80 91 14 02 lds r24, 0x0214 aa8: 90 e0 ldi r25, 0x00 ; 0 aaa: 30 e0 ldi r19, 0x00 ; 0 aac: 28 17 cp r18, r24 aae: 39 07 cpc r19, r25 ab0: 84 f4 brge .+32 ; 0xad2 ab2: 80 91 13 02 lds r24, 0x0213 ab6: 81 30 cpi r24, 0x01 ; 1 ab8: 61 f4 brne .+24 ; 0xad2 { SREG = sregsys; return 0; } //insert message qp->message[mlen]=message; aba: e0 91 18 02 lds r30, 0x0218 abe: f0 91 19 02 lds r31, 0x0219 ac2: e2 0f add r30, r18 ac4: f3 1f adc r31, r19 ac6: 50 83 st Z, r21 qp->number++; ac8: 80 91 15 02 lds r24, 0x0215 acc: 8f 5f subi r24, 0xFF ; 255 ace: 80 93 15 02 sts 0x0215, r24 SREG = sregsys; ad2: 80 91 0a 01 lds r24, 0x010A ad6: 8f bf out 0x3f, r24 ; 63 //* * //**************************************************** uint8_t queue_write_byte (Queue *qp, unsigned char message) { sregsys = SREG; ad8: 8f b7 in r24, 0x3f ; 63 ada: 80 93 0a 01 sts 0x010A, r24 cli(); ade: f8 94 cli uint8_t mlen = qp->number; ae0: 20 91 c9 01 lds r18, 0x01C9 if (mlen > (qp->queueDepth - 1) || qp->item_size != 1) ae4: 80 91 c8 01 lds r24, 0x01C8 ae8: 90 e0 ldi r25, 0x00 ; 0 aea: 30 e0 ldi r19, 0x00 ; 0 aec: 28 17 cp r18, r24 aee: 39 07 cpc r19, r25 af0: 84 f4 brge .+32 ; 0xb12 af2: 80 91 c7 01 lds r24, 0x01C7 af6: 81 30 cpi r24, 0x01 ; 1 af8: 61 f4 brne .+24 ; 0xb12 { SREG = sregsys; return 0; } //insert message qp->message[mlen]=message; afa: e0 91 cc 01 lds r30, 0x01CC afe: f0 91 cd 01 lds r31, 0x01CD b02: e2 0f add r30, r18 b04: f3 1f adc r31, r19 b06: 70 83 st Z, r23 qp->number++; b08: 80 91 c9 01 lds r24, 0x01C9 b0c: 8f 5f subi r24, 0xFF ; 255 b0e: 80 93 c9 01 sts 0x01C9, r24 SREG = sregsys; b12: 80 91 0a 01 lds r24, 0x010A b16: 8f bf out 0x3f, r24 ; 63 b18: 72 cf rjmp .-284 ; 0x9fe queue_wait_for_message(&time_calc_queue); calc_msg = queue_read_byte(&time_calc_queue,0,1); // if button 1 is pressed increase hours if (calc_msg == 1) { if (h < 23) b1a: 77 31 cpi r23, 0x17 ; 23 b1c: 30 f0 brcs .+12 ; 0xb2a b1e: 70 e0 ldi r23, 0x00 ; 0 b20: bb cf rjmp .-138 ; 0xa98 h = 0; } // if button 2 is pressed increase minutes else if (calc_msg == 2) { if (m < 59) b22: 5b 33 cpi r21, 0x3B ; 59 b24: 78 f0 brcs .+30 ; 0xb44 b26: 50 e0 ldi r21, 0x00 ; 0 b28: b7 cf rjmp .-146 ; 0xa98 calc_msg = queue_read_byte(&time_calc_queue,0,1); // if button 1 is pressed increase hours if (calc_msg == 1) { if (h < 23) h++; b2a: 7f 5f subi r23, 0xFF ; 255 b2c: b5 cf rjmp .-150 ; 0xa98 TASK_ENTER_CRITICAL; s++; if (s == 60) { s = 0; m++; b2e: 5f 5f subi r21, 0xFF ; 255 if (m == 60) b30: 5c 33 cpi r21, 0x3C ; 60 b32: 11 f0 breq .+4 ; 0xb38 { m = 0; h++; if (h == 24) b34: 60 e0 ldi r22, 0x00 ; 0 b36: a4 cf rjmp .-184 ; 0xa80 s = 0; m++; if (m == 60) { m = 0; h++; b38: 7f 5f subi r23, 0xFF ; 255 if (h == 24) b3a: 78 31 cpi r23, 0x18 ; 24 b3c: 91 f1 breq .+100 ; 0xba2 b3e: 50 e0 ldi r21, 0x00 ; 0 b40: 60 e0 ldi r22, 0x00 ; 0 b42: 9e cf rjmp .-196 ; 0xa80 } // if button 2 is pressed increase minutes else if (calc_msg == 2) { if (m < 59) m++; b44: 5f 5f subi r21, 0xFF ; 255 b46: a8 cf rjmp .-176 ; 0xa98 { SREG = sregsys; return; } //read message tempmsg = qp->message[position]; b48: e0 91 3b 01 lds r30, 0x013B b4c: f0 91 3c 01 lds r31, 0x013C b50: 00 81 ld r16, Z if (delete_message) { //re-organize message queue (FIFO) for (i=position;i<(qp->number)-1;i++) b52: 80 91 38 01 lds r24, 0x0138 b56: 90 e0 ldi r25, 0x00 ; 0 b58: 02 97 sbiw r24, 0x02 ; 2 b5a: ec f0 brlt .+58 ; 0xb96 b5c: 40 e0 ldi r20, 0x00 ; 0 b5e: 20 e0 ldi r18, 0x00 ; 0 b60: 30 e0 ldi r19, 0x00 ; 0 qp->message[i] = qp->message[i+1]; b62: a0 91 3b 01 lds r26, 0x013B b66: b0 91 3c 01 lds r27, 0x013C b6a: a2 0f add r26, r18 b6c: b3 1f adc r27, r19 b6e: e0 91 3b 01 lds r30, 0x013B b72: f0 91 3c 01 lds r31, 0x013C b76: 2f 5f subi r18, 0xFF ; 255 b78: 3f 4f sbci r19, 0xFF ; 255 b7a: e2 0f add r30, r18 b7c: f3 1f adc r31, r19 b7e: 80 81 ld r24, Z b80: 8c 93 st X, r24 //read message tempmsg = qp->message[position]; if (delete_message) { //re-organize message queue (FIFO) for (i=position;i<(qp->number)-1;i++) b82: 4f 5f subi r20, 0xFF ; 255 b84: 80 91 38 01 lds r24, 0x0138 b88: 24 2f mov r18, r20 b8a: 30 e0 ldi r19, 0x00 ; 0 b8c: 90 e0 ldi r25, 0x00 ; 0 b8e: 01 97 sbiw r24, 0x01 ; 1 b90: 28 17 cp r18, r24 b92: 39 07 cpc r19, r25 b94: 34 f3 brlt .-52 ; 0xb62 qp->message[i] = qp->message[i+1]; qp->number--; b96: 80 91 38 01 lds r24, 0x0138 b9a: 81 50 subi r24, 0x01 ; 1 b9c: 80 93 38 01 sts 0x0138, r24 ba0: 57 cf rjmp .-338 ; 0xa50 m++; if (m == 60) { m = 0; h++; if (h == 24) ba2: 70 e0 ldi r23, 0x00 ; 0 ba4: 50 e0 ldi r21, 0x00 ; 0 ba6: 60 e0 ldi r22, 0x00 ; 0 ba8: 6b cf rjmp .-298 ; 0xa80 00000baa : //ISR for Pin Change Interrupts - Buttons void button_press_12() { // button1 is pressed if (! (PINB & _BV(PB1))) baa: 19 9b sbis 0x03, 1 ; 3 bac: 1c c0 rjmp .+56 ; 0xbe6 //Button 1 is pressed so send a "1" to time_calc_task queue_write_byte(&time_calc_queue, 1); return; } // button2 is pressed if (! (PINB & _BV(PB2))) bae: 1a 99 sbic 0x03, 2 ; 3 bb0: 08 95 ret { //disable interrupt fpr debounce PCMSK0 &= ~_BV(PCINT2); bb2: 80 91 6b 00 lds r24, 0x006B bb6: 8b 7f andi r24, 0xFB ; 251 bb8: 80 93 6b 00 sts 0x006B, r24 //* * //**************************************************** uint8_t queue_write_byte (Queue *qp, unsigned char message) { sregsys = SREG; bbc: 8f b7 in r24, 0x3f ; 63 bbe: 80 93 0a 01 sts 0x010A, r24 cli(); bc2: f8 94 cli uint8_t mlen = qp->number; bc4: 20 91 38 01 lds r18, 0x0138 if (mlen > (qp->queueDepth - 1) || qp->item_size != 1) bc8: 80 91 37 01 lds r24, 0x0137 bcc: 90 e0 ldi r25, 0x00 ; 0 bce: 30 e0 ldi r19, 0x00 ; 0 bd0: 28 17 cp r18, r24 bd2: 39 07 cpc r19, r25 bd4: 24 f4 brge .+8 ; 0xbde bd6: 80 91 36 01 lds r24, 0x0136 bda: 81 30 cpi r24, 0x01 ; 1 bdc: 39 f1 breq .+78 ; 0xc2c return 0; } //insert message qp->message[mlen]=message; qp->number++; SREG = sregsys; bde: 80 91 0a 01 lds r24, 0x010A be2: 8f bf out 0x3f, r24 ; 63 be4: 08 95 ret { // button1 is pressed if (! (PINB & _BV(PB1))) { //disable interrupt fpr debounce PCMSK0 &= ~_BV(PCINT1); be6: 80 91 6b 00 lds r24, 0x006B bea: 8d 7f andi r24, 0xFD ; 253 bec: 80 93 6b 00 sts 0x006B, r24 //* * //**************************************************** uint8_t queue_write_byte (Queue *qp, unsigned char message) { sregsys = SREG; bf0: 8f b7 in r24, 0x3f ; 63 bf2: 80 93 0a 01 sts 0x010A, r24 cli(); bf6: f8 94 cli uint8_t mlen = qp->number; bf8: 20 91 38 01 lds r18, 0x0138 if (mlen > (qp->queueDepth - 1) || qp->item_size != 1) bfc: 80 91 37 01 lds r24, 0x0137 c00: 90 e0 ldi r25, 0x00 ; 0 c02: 30 e0 ldi r19, 0x00 ; 0 c04: 28 17 cp r18, r24 c06: 39 07 cpc r19, r25 c08: 54 f7 brge .-44 ; 0xbde c0a: 80 91 36 01 lds r24, 0x0136 c0e: 81 30 cpi r24, 0x01 ; 1 c10: 31 f7 brne .-52 ; 0xbde { SREG = sregsys; return 0; } //insert message qp->message[mlen]=message; c12: e0 91 3b 01 lds r30, 0x013B c16: f0 91 3c 01 lds r31, 0x013C c1a: e2 0f add r30, r18 c1c: f3 1f adc r31, r19 c1e: 80 83 st Z, r24 qp->number++; c20: 80 91 38 01 lds r24, 0x0138 c24: 8f 5f subi r24, 0xFF ; 255 c26: 80 93 38 01 sts 0x0138, r24 c2a: d9 cf rjmp .-78 ; 0xbde { SREG = sregsys; return 0; } //insert message qp->message[mlen]=message; c2c: e0 91 3b 01 lds r30, 0x013B c30: f0 91 3c 01 lds r31, 0x013C c34: e2 0f add r30, r18 c36: f3 1f adc r31, r19 c38: 82 e0 ldi r24, 0x02 ; 2 c3a: 80 83 st Z, r24 qp->number++; c3c: 80 91 38 01 lds r24, 0x0138 c40: 8f 5f subi r24, 0xFF ; 255 c42: 80 93 38 01 sts 0x0138, r24 SREG = sregsys; c46: 80 91 0a 01 lds r24, 0x010A c4a: 8f bf out 0x3f, r24 ; 63 c4c: 08 95 ret 00000c4e <__vector_3>: { tick_time(); } SIGNAL(SIG_PIN_CHANGE0) { c4e: 1f 92 push r1 c50: 0f 92 push r0 c52: 0f b6 in r0, 0x3f ; 63 c54: 0f 92 push r0 c56: 11 24 eor r1, r1 c58: 2f 93 push r18 c5a: 3f 93 push r19 c5c: 8f 93 push r24 c5e: 9f 93 push r25 c60: ef 93 push r30 c62: ff 93 push r31 //ISR for Pin Change Interrupts - Buttons void button_press_12() { // button1 is pressed if (! (PINB & _BV(PB1))) c64: 19 9b sbis 0x03, 1 ; 3 c66: 27 c0 rjmp .+78 ; 0xcb6 <__vector_3+0x68> //Button 1 is pressed so send a "1" to time_calc_task queue_write_byte(&time_calc_queue, 1); return; } // button2 is pressed if (! (PINB & _BV(PB2))) c68: 1a 9b sbis 0x03, 2 ; 3 c6a: 0b c0 rjmp .+22 ; 0xc82 <__vector_3+0x34> button_press_12(); } c6c: ff 91 pop r31 c6e: ef 91 pop r30 c70: 9f 91 pop r25 c72: 8f 91 pop r24 c74: 3f 91 pop r19 c76: 2f 91 pop r18 c78: 0f 90 pop r0 c7a: 0f be out 0x3f, r0 ; 63 c7c: 0f 90 pop r0 c7e: 1f 90 pop r1 c80: 18 95 reti { //disable interrupt fpr debounce PCMSK0 &= ~_BV(PCINT2); c82: 80 91 6b 00 lds r24, 0x006B c86: 8b 7f andi r24, 0xFB ; 251 c88: 80 93 6b 00 sts 0x006B, r24 //* * //**************************************************** uint8_t queue_write_byte (Queue *qp, unsigned char message) { sregsys = SREG; c8c: 8f b7 in r24, 0x3f ; 63 c8e: 80 93 0a 01 sts 0x010A, r24 cli(); c92: f8 94 cli uint8_t mlen = qp->number; c94: 20 91 38 01 lds r18, 0x0138 if (mlen > (qp->queueDepth - 1) || qp->item_size != 1) c98: 80 91 37 01 lds r24, 0x0137 c9c: 90 e0 ldi r25, 0x00 ; 0 c9e: 30 e0 ldi r19, 0x00 ; 0 ca0: 28 17 cp r18, r24 ca2: 39 07 cpc r19, r25 ca4: 24 f4 brge .+8 ; 0xcae <__vector_3+0x60> ca6: 80 91 36 01 lds r24, 0x0136 caa: 81 30 cpi r24, 0x01 ; 1 cac: 39 f1 breq .+78 ; 0xcfc <__vector_3+0xae> return 0; } //insert message qp->message[mlen]=message; qp->number++; SREG = sregsys; cae: 80 91 0a 01 lds r24, 0x010A cb2: 8f bf out 0x3f, r24 ; 63 cb4: db cf rjmp .-74 ; 0xc6c <__vector_3+0x1e> { // button1 is pressed if (! (PINB & _BV(PB1))) { //disable interrupt fpr debounce PCMSK0 &= ~_BV(PCINT1); cb6: 80 91 6b 00 lds r24, 0x006B cba: 8d 7f andi r24, 0xFD ; 253 cbc: 80 93 6b 00 sts 0x006B, r24 //* * //**************************************************** uint8_t queue_write_byte (Queue *qp, unsigned char message) { sregsys = SREG; cc0: 8f b7 in r24, 0x3f ; 63 cc2: 80 93 0a 01 sts 0x010A, r24 cli(); cc6: f8 94 cli uint8_t mlen = qp->number; cc8: 20 91 38 01 lds r18, 0x0138 if (mlen > (qp->queueDepth - 1) || qp->item_size != 1) ccc: 80 91 37 01 lds r24, 0x0137 cd0: 90 e0 ldi r25, 0x00 ; 0 cd2: 30 e0 ldi r19, 0x00 ; 0 cd4: 28 17 cp r18, r24 cd6: 39 07 cpc r19, r25 cd8: 54 f7 brge .-44 ; 0xcae <__vector_3+0x60> cda: 80 91 36 01 lds r24, 0x0136 cde: 81 30 cpi r24, 0x01 ; 1 ce0: 31 f7 brne .-52 ; 0xcae <__vector_3+0x60> { SREG = sregsys; return 0; } //insert message qp->message[mlen]=message; ce2: e0 91 3b 01 lds r30, 0x013B ce6: f0 91 3c 01 lds r31, 0x013C cea: e2 0f add r30, r18 cec: f3 1f adc r31, r19 cee: 80 83 st Z, r24 qp->number++; cf0: 80 91 38 01 lds r24, 0x0138 cf4: 8f 5f subi r24, 0xFF ; 255 cf6: 80 93 38 01 sts 0x0138, r24 cfa: d9 cf rjmp .-78 ; 0xcae <__vector_3+0x60> { SREG = sregsys; return 0; } //insert message qp->message[mlen]=message; cfc: e0 91 3b 01 lds r30, 0x013B d00: f0 91 3c 01 lds r31, 0x013C d04: e2 0f add r30, r18 d06: f3 1f adc r31, r19 d08: 82 e0 ldi r24, 0x02 ; 2 d0a: f1 cf rjmp .-30 ; 0xcee <__vector_3+0xa0> 00000d0c : //ISR for Timer2 - Clock timer void tick_time() { static uint8_t zaehler; zaehler++; d0c: 80 91 0c 01 lds r24, 0x010C d10: 8f 5f subi r24, 0xFF ; 255 d12: 80 93 0c 01 sts 0x010C, r24 if (zaehler == 122) //Interrupt is called @ 8 Mhz / (256*256) = 122 times per second d16: 8a 37 cpi r24, 0x7A ; 122 d18: 81 f0 breq .+32 ; 0xd3a //we have a new second so send a message to time_calc task; zaehler = 0; queue_write_byte(&time_calc_queue, 128); //anything but 1 or 2 } //debounce for buttons (enable button interrupts again after 0,3 seconds; else if (!(zaehler % 30)) d1a: 6e e1 ldi r22, 0x1E ; 30 d1c: 0e 94 b9 0b call 0x1772 ; 0x1772 <__udivmodqi4> d20: 99 23 and r25, r25 d22: 51 f4 brne .+20 ; 0xd38 { PCMSK0 |= _BV(PCINT1); d24: 80 91 6b 00 lds r24, 0x006B d28: 82 60 ori r24, 0x02 ; 2 d2a: 80 93 6b 00 sts 0x006B, r24 PCMSK0 |= _BV(PCINT2); d2e: 80 91 6b 00 lds r24, 0x006B d32: 84 60 ori r24, 0x04 ; 4 d34: 80 93 6b 00 sts 0x006B, r24 d38: 08 95 ret static uint8_t zaehler; zaehler++; if (zaehler == 122) //Interrupt is called @ 8 Mhz / (256*256) = 122 times per second { //we have a new second so send a message to time_calc task; zaehler = 0; d3a: 10 92 0c 01 sts 0x010C, r1 //* * //**************************************************** uint8_t queue_write_byte (Queue *qp, unsigned char message) { sregsys = SREG; d3e: 8f b7 in r24, 0x3f ; 63 d40: 80 93 0a 01 sts 0x010A, r24 cli(); d44: f8 94 cli uint8_t mlen = qp->number; d46: 20 91 38 01 lds r18, 0x0138 if (mlen > (qp->queueDepth - 1) || qp->item_size != 1) d4a: 80 91 37 01 lds r24, 0x0137 d4e: 90 e0 ldi r25, 0x00 ; 0 d50: 30 e0 ldi r19, 0x00 ; 0 d52: 28 17 cp r18, r24 d54: 39 07 cpc r19, r25 d56: 8c f4 brge .+34 ; 0xd7a d58: 80 91 36 01 lds r24, 0x0136 d5c: 81 30 cpi r24, 0x01 ; 1 d5e: 69 f4 brne .+26 ; 0xd7a { SREG = sregsys; return 0; } //insert message qp->message[mlen]=message; d60: e0 91 3b 01 lds r30, 0x013B d64: f0 91 3c 01 lds r31, 0x013C d68: e2 0f add r30, r18 d6a: f3 1f adc r31, r19 d6c: 80 e8 ldi r24, 0x80 ; 128 d6e: 80 83 st Z, r24 qp->number++; d70: 80 91 38 01 lds r24, 0x0138 d74: 8f 5f subi r24, 0xFF ; 255 d76: 80 93 38 01 sts 0x0138, r24 SREG = sregsys; d7a: 80 91 0a 01 lds r24, 0x010A d7e: 8f bf out 0x3f, r24 ; 63 d80: 08 95 ret 00000d82 <__vector_9>: void button_press_12(void); //Interrupt Handler SIGNAL (TIMER2_OVF_vect) { d82: 1f 92 push r1 d84: 0f 92 push r0 d86: 0f b6 in r0, 0x3f ; 63 d88: 0f 92 push r0 d8a: 11 24 eor r1, r1 d8c: 2f 93 push r18 d8e: 3f 93 push r19 d90: 6f 93 push r22 d92: 7f 93 push r23 d94: 8f 93 push r24 d96: 9f 93 push r25 d98: ef 93 push r30 d9a: ff 93 push r31 //ISR for Timer2 - Clock timer void tick_time() { static uint8_t zaehler; zaehler++; d9c: 80 91 0c 01 lds r24, 0x010C da0: 8f 5f subi r24, 0xFF ; 255 da2: 80 93 0c 01 sts 0x010C, r24 if (zaehler == 122) //Interrupt is called @ 8 Mhz / (256*256) = 122 times per second da6: 8a 37 cpi r24, 0x7A ; 122 da8: e1 f0 breq .+56 ; 0xde2 <__vector_9+0x60> //we have a new second so send a message to time_calc task; zaehler = 0; queue_write_byte(&time_calc_queue, 128); //anything but 1 or 2 } //debounce for buttons (enable button interrupts again after 0,3 seconds; else if (!(zaehler % 30)) daa: 6e e1 ldi r22, 0x1E ; 30 dac: 0e 94 b9 0b call 0x1772 ; 0x1772 <__udivmodqi4> db0: 99 23 and r25, r25 db2: 51 f4 brne .+20 ; 0xdc8 <__vector_9+0x46> { PCMSK0 |= _BV(PCINT1); db4: 80 91 6b 00 lds r24, 0x006B db8: 82 60 ori r24, 0x02 ; 2 dba: 80 93 6b 00 sts 0x006B, r24 PCMSK0 |= _BV(PCINT2); dbe: 80 91 6b 00 lds r24, 0x006B dc2: 84 60 ori r24, 0x04 ; 4 dc4: 80 93 6b 00 sts 0x006B, r24 tick_time(); } dc8: ff 91 pop r31 dca: ef 91 pop r30 dcc: 9f 91 pop r25 dce: 8f 91 pop r24 dd0: 7f 91 pop r23 dd2: 6f 91 pop r22 dd4: 3f 91 pop r19 dd6: 2f 91 pop r18 dd8: 0f 90 pop r0 dda: 0f be out 0x3f, r0 ; 63 ddc: 0f 90 pop r0 dde: 1f 90 pop r1 de0: 18 95 reti static uint8_t zaehler; zaehler++; if (zaehler == 122) //Interrupt is called @ 8 Mhz / (256*256) = 122 times per second { //we have a new second so send a message to time_calc task; zaehler = 0; de2: 10 92 0c 01 sts 0x010C, r1 //* * //**************************************************** uint8_t queue_write_byte (Queue *qp, unsigned char message) { sregsys = SREG; de6: 8f b7 in r24, 0x3f ; 63 de8: 80 93 0a 01 sts 0x010A, r24 cli(); dec: f8 94 cli uint8_t mlen = qp->number; dee: 20 91 38 01 lds r18, 0x0138 if (mlen > (qp->queueDepth - 1) || qp->item_size != 1) df2: 80 91 37 01 lds r24, 0x0137 df6: 90 e0 ldi r25, 0x00 ; 0 df8: 30 e0 ldi r19, 0x00 ; 0 dfa: 28 17 cp r18, r24 dfc: 39 07 cpc r19, r25 dfe: 8c f4 brge .+34 ; 0xe22 <__vector_9+0xa0> e00: 80 91 36 01 lds r24, 0x0136 e04: 81 30 cpi r24, 0x01 ; 1 e06: 69 f4 brne .+26 ; 0xe22 <__vector_9+0xa0> { SREG = sregsys; return 0; } //insert message qp->message[mlen]=message; e08: e0 91 3b 01 lds r30, 0x013B e0c: f0 91 3c 01 lds r31, 0x013C e10: e2 0f add r30, r18 e12: f3 1f adc r31, r19 e14: 80 e8 ldi r24, 0x80 ; 128 e16: 80 83 st Z, r24 qp->number++; e18: 80 91 38 01 lds r24, 0x0138 e1c: 8f 5f subi r24, 0xFF ; 255 e1e: 80 93 38 01 sts 0x0138, r24 SREG = sregsys; e22: 80 91 0a 01 lds r24, 0x010A e26: 8f bf out 0x3f, r24 ; 63 e28: cf cf rjmp .-98 ; 0xdc8 <__vector_9+0x46> 00000e2a
: #ifdef TASK_USE_SEMAPHORE #include "system/semaphore.c" #endif int main() { e2a: df 93 push r29 e2c: cf 93 push r28 e2e: cd b7 in r28, 0x3d ; 61 e30: de b7 in r29, 0x3e ; 62 e32: c5 54 subi r28, 0x45 ; 69 e34: d0 40 sbci r29, 0x00 ; 0 e36: 0f b6 in r0, 0x3f ; 63 e38: f8 94 cli e3a: de bf out 0x3e, r29 ; 62 e3c: 0f be out 0x3f, r0 ; 63 e3e: cd bf out 0x3d, r28 ; 61 //* output: none * //**************************************************** void task_create(Task *t, TaskFunction f, TaskPrio prio) { sregsys = SREG; e40: 8f b7 in r24, 0x3f ; 63 e42: 80 93 0a 01 sts 0x010A, r24 cli(); e46: f8 94 cli e48: 80 e0 ldi r24, 0x00 ; 0 e4a: 90 e0 ldi r25, 0x00 ; 0 e4c: 9e 01 movw r18, r28 e4e: 2f 5f subi r18, 0xFF ; 255 e50: 3f 4f sbci r19, 0xFF ; 255 signed char a; unsigned char *s = (unsigned char *)(t->stack + sizeof(t->stack) - 3); for (a=31; a>=0; a--) *s-- = 0; e52: f9 01 movw r30, r18 e54: e8 0f add r30, r24 e56: f9 1f adc r31, r25 e58: ee 5b subi r30, 0xBE ; 190 e5a: ff 4f sbci r31, 0xFF ; 255 e5c: 10 82 st Z, r1 e5e: 01 97 sbiw r24, 0x01 ; 1 e60: 4f ef ldi r20, 0xFF ; 255 e62: 80 3e cpi r24, 0xE0 ; 224 e64: 94 07 cpc r25, r20 e66: a9 f7 brne .-22 ; 0xe52 //init kontext: sreg = 0, SP = Pointer to t->stack (which contains the stack section and the PC) t->sreg = 0; e68: 1a 82 std Y+2, r1 ; 0x02 t->sp = (unsigned char *)(t->stack + sizeof(t->stack) - 3); e6a: ce 01 movw r24, r28 e6c: 8d 5b subi r24, 0xBD ; 189 e6e: 9f 4f sbci r25, 0xFF ; 255 e70: 9c 83 std Y+4, r25 ; 0x04 e72: 8b 83 std Y+3, r24 ; 0x03 t->prio = prio; e74: 8f ef ldi r24, 0xFF ; 255 e76: 8d 83 std Y+5, r24 ; 0x05 t->stack[sizeof(t->stack)-2] = ((unsigned int)f)>>8; e78: 8a e6 ldi r24, 0x6A ; 106 e7a: 92 e0 ldi r25, 0x02 ; 2 e7c: fe 01 movw r30, r28 e7e: ec 5b subi r30, 0xBC ; 188 e80: ff 4f sbci r31, 0xFF ; 255 e82: 90 83 st Z, r25 t->stack[sizeof(t->stack)-1] = ((unsigned int)f)&0xff; e84: fe 01 movw r30, r28 e86: eb 5b subi r30, 0xBB ; 187 e88: ff 4f sbci r31, 0xFF ; 255 e8a: 80 83 st Z, r24 e8c: 46 e1 ldi r20, 0x16 ; 22 e8e: 51 e0 ldi r21, 0x01 ; 1 e90: da 01 movw r26, r20 e92: e0 e0 ldi r30, 0x00 ; 0 e94: f0 e0 ldi r31, 0x00 ; 0 t->laps = 0; #endif for (a=0; a ea0: 7a c1 rjmp .+756 ; 0x1196 { t->ID = a; tasks[a] = t; ea2: 31 96 adiw r30, 0x01 ; 1 ea4: 12 96 adiw r26, 0x02 ; 2 #ifdef TASK_USE_SIGNAL t->state = TaskStateActive; t->laps = 0; #endif for (a=0; a t->ID = a; tasks[a] = t; break; } } SREG = sregsys; eac: 80 91 0a 01 lds r24, 0x010A eb0: 8f bf out 0x3f, r24 ; 63 //Create an idle-task Task idletask; task_create(&idletask,idle,TaskPriorityLow); //enable watchdog wdt_enable(WDTO_2S); eb2: 2f e0 ldi r18, 0x0F ; 15 eb4: 88 e1 ldi r24, 0x18 ; 24 eb6: 90 e0 ldi r25, 0x00 ; 0 eb8: 0f b6 in r0, 0x3f ; 63 eba: f8 94 cli ebc: a8 95 wdr ebe: 80 93 60 00 sts 0x0060, r24 ec2: 0f be out 0x3f, r0 ; 63 ec4: 20 93 60 00 sts 0x0060, r18 //+++Init user stuff+++ static void init_user_environment() { //Create Tasks for displaying minutes, hours and time calculation task_create(&display_minutes_task, display_minutes, TaskPriorityLow); ec8: 2b ef ldi r18, 0xFB ; 251 eca: 39 e0 ldi r19, 0x09 ; 9 //* output: none * //**************************************************** void task_create(Task *t, TaskFunction f, TaskPrio prio) { sregsys = SREG; ecc: 8f b7 in r24, 0x3f ; 63 ece: 80 93 0a 01 sts 0x010A, r24 cli(); ed2: f8 94 cli ed4: 80 e0 ldi r24, 0x00 ; 0 ed6: 90 e0 ldi r25, 0x00 ; 0 signed char a; unsigned char *s = (unsigned char *)(t->stack + sizeof(t->stack) - 3); for (a=31; a>=0; a--) *s-- = 0; ed8: fc 01 movw r30, r24 eda: ec 53 subi r30, 0x3C ; 60 edc: fe 4f sbci r31, 0xFE ; 254 ede: 10 82 st Z, r1 ee0: 01 97 sbiw r24, 0x01 ; 1 ee2: 6f ef ldi r22, 0xFF ; 255 ee4: 80 3e cpi r24, 0xE0 ; 224 ee6: 96 07 cpc r25, r22 ee8: b9 f7 brne .-18 ; 0xed8 //init kontext: sreg = 0, SP = Pointer to t->stack (which contains the stack section and the PC) t->sreg = 0; eea: 10 92 83 01 sts 0x0183, r1 t->sp = (unsigned char *)(t->stack + sizeof(t->stack) - 3); eee: 84 ec ldi r24, 0xC4 ; 196 ef0: 91 e0 ldi r25, 0x01 ; 1 ef2: 90 93 85 01 sts 0x0185, r25 ef6: 80 93 84 01 sts 0x0184, r24 t->prio = prio; efa: 8f ef ldi r24, 0xFF ; 255 efc: 80 93 86 01 sts 0x0186, r24 t->stack[sizeof(t->stack)-2] = ((unsigned int)f)>>8; f00: 30 93 c5 01 sts 0x01C5, r19 t->stack[sizeof(t->stack)-1] = ((unsigned int)f)&0xff; f04: 20 93 c6 01 sts 0x01C6, r18 f08: a6 e1 ldi r26, 0x16 ; 22 f0a: b1 e0 ldi r27, 0x01 ; 1 f0c: e0 e0 ldi r30, 0x00 ; 0 f0e: f0 e0 ldi r31, 0x00 ; 0 t->laps = 0; #endif for (a=0; a f1a: 32 c1 rjmp .+612 ; 0x1180 { t->ID = a; tasks[a] = t; f1c: 31 96 adiw r30, 0x01 ; 1 f1e: 12 96 adiw r26, 0x02 ; 2 #ifdef TASK_USE_SIGNAL t->state = TaskStateActive; t->laps = 0; #endif for (a=0; a t->ID = a; tasks[a] = t; break; } } SREG = sregsys; f26: 80 91 0a 01 lds r24, 0x010A f2a: 8f bf out 0x3f, r24 ; 63 task_create(&display_hours_task, display_hours, TaskPriorityLow); f2c: 23 ed ldi r18, 0xD3 ; 211 f2e: 38 e0 ldi r19, 0x08 ; 8 //* output: none * //**************************************************** void task_create(Task *t, TaskFunction f, TaskPrio prio) { sregsys = SREG; f30: 8f b7 in r24, 0x3f ; 63 f32: 80 93 0a 01 sts 0x010A, r24 cli(); f36: f8 94 cli f38: 80 e0 ldi r24, 0x00 ; 0 f3a: 90 e0 ldi r25, 0x00 ; 0 signed char a; unsigned char *s = (unsigned char *)(t->stack + sizeof(t->stack) - 3); for (a=31; a>=0; a--) *s-- = 0; f3c: fc 01 movw r30, r24 f3e: e0 5f subi r30, 0xF0 ; 240 f40: fd 4f sbci r31, 0xFD ; 253 f42: 10 82 st Z, r1 f44: 01 97 sbiw r24, 0x01 ; 1 f46: af ef ldi r26, 0xFF ; 255 f48: 80 3e cpi r24, 0xE0 ; 224 f4a: 9a 07 cpc r25, r26 f4c: b9 f7 brne .-18 ; 0xf3c //init kontext: sreg = 0, SP = Pointer to t->stack (which contains the stack section and the PC) t->sreg = 0; f4e: 10 92 cf 01 sts 0x01CF, r1 t->sp = (unsigned char *)(t->stack + sizeof(t->stack) - 3); f52: 80 e1 ldi r24, 0x10 ; 16 f54: 92 e0 ldi r25, 0x02 ; 2 f56: 90 93 d1 01 sts 0x01D1, r25 f5a: 80 93 d0 01 sts 0x01D0, r24 t->prio = prio; f5e: 8f ef ldi r24, 0xFF ; 255 f60: 80 93 d2 01 sts 0x01D2, r24 t->stack[sizeof(t->stack)-2] = ((unsigned int)f)>>8; f64: 30 93 11 02 sts 0x0211, r19 t->stack[sizeof(t->stack)-1] = ((unsigned int)f)&0xff; f68: 20 93 12 02 sts 0x0212, r18 f6c: a6 e1 ldi r26, 0x16 ; 22 f6e: b1 e0 ldi r27, 0x01 ; 1 f70: e0 e0 ldi r30, 0x00 ; 0 f72: f0 e0 ldi r31, 0x00 ; 0 t->laps = 0; #endif for (a=0; a f7e: f5 c0 rjmp .+490 ; 0x116a { t->ID = a; tasks[a] = t; f80: 31 96 adiw r30, 0x01 ; 1 f82: 12 96 adiw r26, 0x02 ; 2 #ifdef TASK_USE_SIGNAL t->state = TaskStateActive; t->laps = 0; #endif for (a=0; a t->ID = a; tasks[a] = t; break; } } SREG = sregsys; f8a: 80 91 0a 01 lds r24, 0x010A f8e: 8f bf out 0x3f, r24 ; 63 task_create(&time_calc_task, time_calc, TaskPriorityLow); f90: 22 ef ldi r18, 0xF2 ; 242 f92: 34 e0 ldi r19, 0x04 ; 4 //* output: none * //**************************************************** void task_create(Task *t, TaskFunction f, TaskPrio prio) { sregsys = SREG; f94: 8f b7 in r24, 0x3f ; 63 f96: 80 93 0a 01 sts 0x010A, r24 cli(); f9a: f8 94 cli f9c: 80 e0 ldi r24, 0x00 ; 0 f9e: 90 e0 ldi r25, 0x00 ; 0 signed char a; unsigned char *s = (unsigned char *)(t->stack + sizeof(t->stack) - 3); for (a=31; a>=0; a--) *s-- = 0; fa0: fc 01 movw r30, r24 fa2: e1 58 subi r30, 0x81 ; 129 fa4: fe 4f sbci r31, 0xFE ; 254 fa6: 10 82 st Z, r1 fa8: 01 97 sbiw r24, 0x01 ; 1 faa: bf ef ldi r27, 0xFF ; 255 fac: 80 3e cpi r24, 0xE0 ; 224 fae: 9b 07 cpc r25, r27 fb0: b9 f7 brne .-18 ; 0xfa0 //init kontext: sreg = 0, SP = Pointer to t->stack (which contains the stack section and the PC) t->sreg = 0; fb2: 10 92 3e 01 sts 0x013E, r1 t->sp = (unsigned char *)(t->stack + sizeof(t->stack) - 3); fb6: 8f e7 ldi r24, 0x7F ; 127 fb8: 91 e0 ldi r25, 0x01 ; 1 fba: 90 93 40 01 sts 0x0140, r25 fbe: 80 93 3f 01 sts 0x013F, r24 t->prio = prio; fc2: 8f ef ldi r24, 0xFF ; 255 fc4: 80 93 41 01 sts 0x0141, r24 t->stack[sizeof(t->stack)-2] = ((unsigned int)f)>>8; fc8: 30 93 80 01 sts 0x0180, r19 t->stack[sizeof(t->stack)-1] = ((unsigned int)f)&0xff; fcc: 20 93 81 01 sts 0x0181, r18 fd0: e0 e0 ldi r30, 0x00 ; 0 fd2: f0 e0 ldi r31, 0x00 ; 0 t->laps = 0; #endif for (a=0; a fde: ba c0 rjmp .+372 ; 0x1154 { t->ID = a; tasks[a] = t; fe0: 31 96 adiw r30, 0x01 ; 1 fe2: 4e 5f subi r20, 0xFE ; 254 fe4: 5f 4f sbci r21, 0xFF ; 255 #ifdef TASK_USE_SIGNAL t->state = TaskStateActive; t->laps = 0; #endif for (a=0; a t->ID = a; tasks[a] = t; break; } } SREG = sregsys; fec: 80 91 0a 01 lds r24, 0x010A ff0: 8f bf out 0x3f, r24 ; 63 //* output: TRUE(ok), ZERO(error) * //*********************************************************************** uint8_t queue_init(Queue *qp, uint8_t MessageQueueDepth, uint8_t item_size) { sregsys = SREG; ff2: 8f b7 in r24, 0x3f ; 63 ff4: 80 93 0a 01 sts 0x010A, r24 cli(); ff8: f8 94 cli { SREG = sregsys; return 0; } //allocate memory for queue dynamically qp->message = (unsigned char*) malloc (MessageQueueDepth*item_size); ffa: 81 e0 ldi r24, 0x01 ; 1 ffc: 90 e0 ldi r25, 0x00 ; 0 ffe: 0e 94 c5 0b call 0x178a ; 0x178a 1002: 90 93 19 02 sts 0x0219, r25 1006: 80 93 18 02 sts 0x0218, r24 if (qp->message == 0 || (uint16_t) qp->message > SP) 100a: 80 91 18 02 lds r24, 0x0218 100e: 90 91 19 02 lds r25, 0x0219 1012: 89 2b or r24, r25 1014: 09 f4 brne .+2 ; 0x1018 1016: 98 c0 rjmp .+304 ; 0x1148 1018: 20 91 18 02 lds r18, 0x0218 101c: 30 91 19 02 lds r19, 0x0219 1020: 8d b7 in r24, 0x3d ; 61 1022: 9e b7 in r25, 0x3e ; 62 1024: 82 17 cp r24, r18 1026: 93 07 cpc r25, r19 1028: 08 f4 brcc .+2 ; 0x102c 102a: 8e c0 rjmp .+284 ; 0x1148 { qp->queueDepth = 0; SREG = sregsys; return 0; } qp->queueDepth = MessageQueueDepth*item_size; 102c: 81 e0 ldi r24, 0x01 ; 1 102e: 80 93 14 02 sts 0x0214, r24 qp->item_size = item_size; 1032: 80 93 13 02 sts 0x0213, r24 qp->ptr = 0; 1036: 10 92 17 02 sts 0x0217, r1 103a: 10 92 16 02 sts 0x0216, r1 SREG = sregsys; 103e: 80 91 0a 01 lds r24, 0x010A 1042: 8f bf out 0x3f, r24 ; 63 //* output: TRUE(ok), ZERO(error) * //*********************************************************************** uint8_t queue_init(Queue *qp, uint8_t MessageQueueDepth, uint8_t item_size) { sregsys = SREG; 1044: 8f b7 in r24, 0x3f ; 63 1046: 80 93 0a 01 sts 0x010A, r24 cli(); 104a: f8 94 cli { SREG = sregsys; return 0; } //allocate memory for queue dynamically qp->message = (unsigned char*) malloc (MessageQueueDepth*item_size); 104c: 81 e0 ldi r24, 0x01 ; 1 104e: 90 e0 ldi r25, 0x00 ; 0 1050: 0e 94 c5 0b call 0x178a ; 0x178a 1054: 90 93 3c 01 sts 0x013C, r25 1058: 80 93 3b 01 sts 0x013B, r24 if (qp->message == 0 || (uint16_t) qp->message > SP) 105c: 80 91 3b 01 lds r24, 0x013B 1060: 90 91 3c 01 lds r25, 0x013C 1064: 89 2b or r24, r25 1066: 09 f4 brne .+2 ; 0x106a 1068: 69 c0 rjmp .+210 ; 0x113c 106a: 20 91 3b 01 lds r18, 0x013B 106e: 30 91 3c 01 lds r19, 0x013C 1072: 8d b7 in r24, 0x3d ; 61 1074: 9e b7 in r25, 0x3e ; 62 1076: 82 17 cp r24, r18 1078: 93 07 cpc r25, r19 107a: 08 f4 brcc .+2 ; 0x107e 107c: 5f c0 rjmp .+190 ; 0x113c { qp->queueDepth = 0; SREG = sregsys; return 0; } qp->queueDepth = MessageQueueDepth*item_size; 107e: 81 e0 ldi r24, 0x01 ; 1 1080: 80 93 37 01 sts 0x0137, r24 qp->item_size = item_size; 1084: 80 93 36 01 sts 0x0136, r24 qp->ptr = 0; 1088: 10 92 3a 01 sts 0x013A, r1 108c: 10 92 39 01 sts 0x0139, r1 SREG = sregsys; 1090: 80 91 0a 01 lds r24, 0x010A 1094: 8f bf out 0x3f, r24 ; 63 //* output: TRUE(ok), ZERO(error) * //*********************************************************************** uint8_t queue_init(Queue *qp, uint8_t MessageQueueDepth, uint8_t item_size) { sregsys = SREG; 1096: 8f b7 in r24, 0x3f ; 63 1098: 80 93 0a 01 sts 0x010A, r24 cli(); 109c: f8 94 cli { SREG = sregsys; return 0; } //allocate memory for queue dynamically qp->message = (unsigned char*) malloc (MessageQueueDepth*item_size); 109e: 82 e0 ldi r24, 0x02 ; 2 10a0: 90 e0 ldi r25, 0x00 ; 0 10a2: 0e 94 c5 0b call 0x178a ; 0x178a 10a6: 90 93 cd 01 sts 0x01CD, r25 10aa: 80 93 cc 01 sts 0x01CC, r24 if (qp->message == 0 || (uint16_t) qp->message > SP) 10ae: 80 91 cc 01 lds r24, 0x01CC 10b2: 90 91 cd 01 lds r25, 0x01CD 10b6: 89 2b or r24, r25 10b8: 09 f4 brne .+2 ; 0x10bc 10ba: 3a c0 rjmp .+116 ; 0x1130 10bc: 20 91 cc 01 lds r18, 0x01CC 10c0: 30 91 cd 01 lds r19, 0x01CD 10c4: 8d b7 in r24, 0x3d ; 61 10c6: 9e b7 in r25, 0x3e ; 62 10c8: 82 17 cp r24, r18 10ca: 93 07 cpc r25, r19 10cc: 88 f1 brcs .+98 ; 0x1130 { qp->queueDepth = 0; SREG = sregsys; return 0; } qp->queueDepth = MessageQueueDepth*item_size; 10ce: 82 e0 ldi r24, 0x02 ; 2 10d0: 80 93 c8 01 sts 0x01C8, r24 qp->item_size = item_size; 10d4: 81 e0 ldi r24, 0x01 ; 1 10d6: 80 93 c7 01 sts 0x01C7, r24 qp->ptr = 0; 10da: 10 92 cb 01 sts 0x01CB, r1 10de: 10 92 ca 01 sts 0x01CA, r1 SREG = sregsys; 10e2: 80 91 0a 01 lds r24, 0x010A 10e6: 8f bf out 0x3f, r24 ; 63 queue_init(&minutes_queue,1,1); queue_init(&time_calc_queue,1,1); queue_init(&hours_queue,2,1); //set DDRB and DDRC as output DDRC=0xFF; 10e8: 8f ef ldi r24, 0xFF ; 255 10ea: 87 b9 out 0x07, r24 ; 7 DDRD=0xFF; 10ec: 8a b9 out 0x0a, r24 ; 10 //setup timer2 TCCR2B = _BV(CS22) | _BV(CS21); // div by 256 10ee: 86 e0 ldi r24, 0x06 ; 6 10f0: 80 93 b1 00 sts 0x00B1, r24 // We will overflow 122 times a second, and call an interrupt // enable interrupt TIMSK2 = _BV(TOIE2); 10f4: 91 e0 ldi r25, 0x01 ; 1 10f6: 90 93 70 00 sts 0x0070, r25 //Enable pullup resistor on PIN PB1 and PB2 PORTB = _BV(PB1) | _BV(PB2); 10fa: 85 b9 out 0x05, r24 ; 5 //These are the interrupts for the buttons PCICR = _BV(PCIE0); 10fc: 90 93 68 00 sts 0x0068, r25 PCMSK0 = _BV(PCINT1) | _BV(PCINT2); 1100: 80 93 6b 00 sts 0x006B, r24 //* output: none * //**************************************************** void task_switch() { cli(); 1104: f8 94 cli set_sleep_mode(SLEEP_MODE_IDLE); 1106: 83 b7 in r24, 0x33 ; 51 1108: 81 7f andi r24, 0xF1 ; 241 110a: 83 bf out 0x33, r24 ; 51 TCNT0 = 0xf0; 110c: 80 ef ldi r24, 0xF0 ; 240 110e: 86 bd out 0x26, r24 ; 38 TIMER_REG = _BV(CS00); 1110: 81 e0 ldi r24, 0x01 ; 1 1112: 85 bd out 0x25, r24 ; 37 TIMER_ENABLE |= _BV(TOIE0); 1114: 80 91 6e 00 lds r24, 0x006E 1118: 81 60 ori r24, 0x01 ; 1 111a: 80 93 6e 00 sts 0x006E, r24 sei(); 111e: 78 94 sei sleep_mode(); 1120: 83 b7 in r24, 0x33 ; 51 1122: 81 60 ori r24, 0x01 ; 1 1124: 83 bf out 0x33, r24 ; 51 1126: 88 95 sleep 1128: 83 b7 in r24, 0x33 ; 51 112a: 8e 7f andi r24, 0xFE ; 254 112c: 83 bf out 0x33, r24 ; 51 112e: ff cf rjmp .-2 ; 0x112e } //allocate memory for queue dynamically qp->message = (unsigned char*) malloc (MessageQueueDepth*item_size); if (qp->message == 0 || (uint16_t) qp->message > SP) { qp->queueDepth = 0; 1130: 10 92 c8 01 sts 0x01C8, r1 SREG = sregsys; 1134: 80 91 0a 01 lds r24, 0x010A 1138: 8f bf out 0x3f, r24 ; 63 113a: d6 cf rjmp .-84 ; 0x10e8 } //allocate memory for queue dynamically qp->message = (unsigned char*) malloc (MessageQueueDepth*item_size); if (qp->message == 0 || (uint16_t) qp->message > SP) { qp->queueDepth = 0; 113c: 10 92 37 01 sts 0x0137, r1 SREG = sregsys; 1140: 80 91 0a 01 lds r24, 0x010A 1144: 8f bf out 0x3f, r24 ; 63 1146: a7 cf rjmp .-178 ; 0x1096 } //allocate memory for queue dynamically qp->message = (unsigned char*) malloc (MessageQueueDepth*item_size); if (qp->message == 0 || (uint16_t) qp->message > SP) { qp->queueDepth = 0; 1148: 10 92 14 02 sts 0x0214, r1 SREG = sregsys; 114c: 80 91 0a 01 lds r24, 0x010A 1150: 8f bf out 0x3f, r24 ; 63 1152: 78 cf rjmp .-272 ; 0x1044 for (a=0; aID = a; 1154: e0 93 3d 01 sts 0x013D, r30 tasks[a] = t; 1158: ee 0f add r30, r30 115a: ff 1f adc r31, r31 115c: ea 5e subi r30, 0xEA ; 234 115e: fe 4f sbci r31, 0xFE ; 254 1160: 8d e3 ldi r24, 0x3D ; 61 1162: 91 e0 ldi r25, 0x01 ; 1 1164: 91 83 std Z+1, r25 ; 0x01 1166: 80 83 st Z, r24 1168: 41 cf rjmp .-382 ; 0xfec for (a=0; aID = a; 116a: e0 93 ce 01 sts 0x01CE, r30 tasks[a] = t; 116e: ee 0f add r30, r30 1170: ff 1f adc r31, r31 1172: ea 5e subi r30, 0xEA ; 234 1174: fe 4f sbci r31, 0xFE ; 254 1176: 8e ec ldi r24, 0xCE ; 206 1178: 91 e0 ldi r25, 0x01 ; 1 117a: 91 83 std Z+1, r25 ; 0x01 117c: 80 83 st Z, r24 117e: 05 cf rjmp .-502 ; 0xf8a for (a=0; aID = a; 1180: e0 93 82 01 sts 0x0182, r30 tasks[a] = t; 1184: ee 0f add r30, r30 1186: ff 1f adc r31, r31 1188: ea 5e subi r30, 0xEA ; 234 118a: fe 4f sbci r31, 0xFE ; 254 118c: 82 e8 ldi r24, 0x82 ; 130 118e: 91 e0 ldi r25, 0x01 ; 1 1190: 91 83 std Z+1, r25 ; 0x01 1192: 80 83 st Z, r24 1194: c8 ce rjmp .-624 ; 0xf26 for (a=0; aID = a; 1196: e9 83 std Y+1, r30 ; 0x01 tasks[a] = t; 1198: ee 0f add r30, r30 119a: ff 1f adc r31, r31 119c: ea 5e subi r30, 0xEA ; 234 119e: fe 4f sbci r31, 0xFE ; 254 11a0: 31 83 std Z+1, r19 ; 0x01 11a2: 20 83 st Z, r18 11a4: 83 ce rjmp .-762 ; 0xeac 000011a6 : } } //this is the display task for the hours void display_hours() { 11a6: 0f 93 push r16 11a8: 1f 93 push r17 11aa: cf 93 push r28 11ac: df 93 push r29 //* output: free places in the queue * //**************************************************** uint8_t queue_exists(Queue *qp) { if (qp->queueDepth) 11ae: 80 91 c8 01 lds r24, 0x01C8 11b2: 88 23 and r24, r24 11b4: 09 f4 brne .+2 ; 0x11b8 11b6: 9d c0 rjmp .+314 ; 0x12f2 //* description: check if memory is available * //* input: no * //* output: number of free memory blocks * //**************************************************** uint8_t memory_get_free_blocks() {return MAXBLOCKS - currentBlocks;} 11b8: 80 91 0b 01 lds r24, 0x010B if (!(queue_exists(&hours_queue)) || !(memory_get_free_blocks())) 11bc: 82 30 cpi r24, 0x02 ; 2 11be: 09 f4 brne .+2 ; 0x11c2 11c0: 98 c0 rjmp .+304 ; 0x12f2 //* output: pointer to memory block or 0 (error) * //**************************************************** void* memory_allocate_block() { sregsys = SREG; 11c2: 8f b7 in r24, 0x3f ; 63 11c4: 80 93 0a 01 sts 0x010A, r24 cli(); 11c8: f8 94 cli if (currentBlocks >= MAXBLOCKS) 11ca: 80 91 0b 01 lds r24, 0x010B 11ce: 82 30 cpi r24, 0x02 ; 2 11d0: 08 f0 brcs .+2 ; 0x11d4 11d2: 89 c0 rjmp .+274 ; 0x12e6 SREG = sregsys; return 0; } uint8_t a; char* ptr; mem_block_intern* block = (blocks+currentBlocks); 11d4: 90 91 0b 01 lds r25, 0x010B 11d8: 83 e0 ldi r24, 0x03 ; 3 11da: 98 9f mul r25, r24 11dc: f0 01 movw r30, r0 11de: 11 24 eor r1, r1 11e0: e0 5f subi r30, 0xF0 ; 240 11e2: fe 4f sbci r31, 0xFE ; 254 //insert block //set a pointer to the memory block block->ptr = data+(currentBlocks*BLOCKSIZE); 11e4: 80 91 0b 01 lds r24, 0x010B 11e8: 90 e0 ldi r25, 0x00 ; 0 11ea: 82 5f subi r24, 0xF2 ; 242 11ec: 9e 4f sbci r25, 0xFE ; 254 11ee: 92 83 std Z+2, r25 ; 0x02 11f0: 81 83 std Z+1, r24 ; 0x01 ptr = (char*) block->ptr; 11f2: a1 81 ldd r26, Z+1 ; 0x01 11f4: b2 81 ldd r27, Z+2 ; 0x02 //leave if theres not enough memory if (block->ptr == 0 || (uint16_t) block->ptr > HEAPSTART) 11f6: 81 81 ldd r24, Z+1 ; 0x01 11f8: 92 81 ldd r25, Z+2 ; 0x02 11fa: 89 2b or r24, r25 11fc: 09 f4 brne .+2 ; 0x1200 11fe: 73 c0 rjmp .+230 ; 0x12e6 1200: 81 81 ldd r24, Z+1 ; 0x01 1202: 92 81 ldd r25, Z+2 ; 0x02 1204: 80 50 subi r24, 0x00 ; 0 1206: 93 40 sbci r25, 0x03 ; 3 1208: 08 f0 brcs .+2 ; 0x120c 120a: 6d c0 rjmp .+218 ; 0x12e6 SREG = sregsys; return 0; } //clear memory for (a=0;aowner = currentTask; 120e: 80 91 00 01 lds r24, 0x0100 1212: 80 83 st Z, r24 currentBlocks++; 1214: 80 91 0b 01 lds r24, 0x010B 1218: 8f 5f subi r24, 0xFF ; 255 121a: 80 93 0b 01 sts 0x010B, r24 SREG = sregsys; 121e: 80 91 0a 01 lds r24, 0x010A 1222: 8f bf out 0x3f, r24 ; 63 //return pointer to memory block return (void*) block->ptr; 1224: c1 81 ldd r28, Z+1 ; 0x01 1226: d2 81 ldd r29, Z+2 ; 0x02 //**************************************************** uint8_t queue_wait_for_message(Queue *qp) { //enable multitasking to avoid a deadrun wdt_enable(WDTO_2S); 1228: 08 e1 ldi r16, 0x18 ; 24 122a: 10 e0 ldi r17, 0x00 ; 0 122c: 7f e0 ldi r23, 0x0F ; 15 TIMER_ENABLE |= _BV(TOIE0); sei(); if (qp->queueDepth == 0) return 0; while (qp->number == 0) TCNT0=0xFF; 122e: 5f ef ldi r21, 0xFF ; 255 //**************************************************** uint8_t queue_wait_for_message(Queue *qp) { //enable multitasking to avoid a deadrun wdt_enable(WDTO_2S); 1230: 0f b6 in r0, 0x3f ; 63 1232: f8 94 cli 1234: a8 95 wdr 1236: 00 93 60 00 sts 0x0060, r16 123a: 0f be out 0x3f, r0 ; 63 123c: 70 93 60 00 sts 0x0060, r23 TIMER_ENABLE |= _BV(TOIE0); 1240: 80 91 6e 00 lds r24, 0x006E 1244: 81 60 ori r24, 0x01 ; 1 1246: 80 93 6e 00 sts 0x006E, r24 sei(); 124a: 78 94 sei if (qp->queueDepth == 0) 124c: 80 91 c8 01 lds r24, 0x01C8 1250: 88 23 and r24, r24 1252: 11 f4 brne .+4 ; 0x1258 1254: 05 c0 rjmp .+10 ; 0x1260 return 0; while (qp->number == 0) TCNT0=0xFF; 1256: 56 bd out 0x26, r21 ; 38 wdt_enable(WDTO_2S); TIMER_ENABLE |= _BV(TOIE0); sei(); if (qp->queueDepth == 0) return 0; while (qp->number == 0) 1258: 80 91 c9 01 lds r24, 0x01C9 125c: 88 23 and r24, r24 125e: d9 f3 breq .-10 ; 0x1256 //* * //*********************************************************************** unsigned char queue_read_byte(Queue *qp, uint8_t position, uint8_t delete_message) { sregsys = SREG; 1260: 8f b7 in r24, 0x3f ; 63 1262: 80 93 0a 01 sts 0x010A, r24 cli(); 1266: f8 94 cli uint8_t i; unsigned char tempmsg; if (qp->number == 0 || qp->number <= position || qp->item_size != 1) 1268: 80 91 c9 01 lds r24, 0x01C9 126c: 88 23 and r24, r24 126e: 41 f0 breq .+16 ; 0x1280 1270: 80 91 c9 01 lds r24, 0x01C9 1274: 88 23 and r24, r24 1276: 21 f0 breq .+8 ; 0x1280 1278: 80 91 c7 01 lds r24, 0x01C7 127c: 81 30 cpi r24, 0x01 ; 1 127e: 31 f0 breq .+12 ; 0x128c //re-organize message queue (FIFO) for (i=position;i<(qp->number)-1;i++) qp->message[i] = qp->message[i+1]; qp->number--; } SREG = sregsys; 1280: 80 91 0a 01 lds r24, 0x010A 1284: 8f bf out 0x3f, r24 ; 63 while (1) { //Wait for new hour message queue_wait_for_message(&hours_queue); //set PORTC to new hour value *hrs_ptr = queue_read_byte(&hours_queue,0,1); 1286: 68 83 st Y, r22 PORTC = *hrs_ptr; 1288: 68 b9 out 0x08, r22 ; 8 128a: d2 cf rjmp .-92 ; 0x1230 { SREG = sregsys; return; } //read message tempmsg = qp->message[position]; 128c: e0 91 cc 01 lds r30, 0x01CC 1290: f0 91 cd 01 lds r31, 0x01CD 1294: 60 81 ld r22, Z if (delete_message) { //re-organize message queue (FIFO) for (i=position;i<(qp->number)-1;i++) 1296: 80 91 c9 01 lds r24, 0x01C9 129a: 90 e0 ldi r25, 0x00 ; 0 129c: 02 97 sbiw r24, 0x02 ; 2 129e: ec f0 brlt .+58 ; 0x12da 12a0: 40 e0 ldi r20, 0x00 ; 0 12a2: 20 e0 ldi r18, 0x00 ; 0 12a4: 30 e0 ldi r19, 0x00 ; 0 qp->message[i] = qp->message[i+1]; 12a6: a0 91 cc 01 lds r26, 0x01CC 12aa: b0 91 cd 01 lds r27, 0x01CD 12ae: a2 0f add r26, r18 12b0: b3 1f adc r27, r19 12b2: e0 91 cc 01 lds r30, 0x01CC 12b6: f0 91 cd 01 lds r31, 0x01CD 12ba: 2f 5f subi r18, 0xFF ; 255 12bc: 3f 4f sbci r19, 0xFF ; 255 12be: e2 0f add r30, r18 12c0: f3 1f adc r31, r19 12c2: 80 81 ld r24, Z 12c4: 8c 93 st X, r24 //read message tempmsg = qp->message[position]; if (delete_message) { //re-organize message queue (FIFO) for (i=position;i<(qp->number)-1;i++) 12c6: 4f 5f subi r20, 0xFF ; 255 12c8: 80 91 c9 01 lds r24, 0x01C9 12cc: 24 2f mov r18, r20 12ce: 30 e0 ldi r19, 0x00 ; 0 12d0: 90 e0 ldi r25, 0x00 ; 0 12d2: 01 97 sbiw r24, 0x01 ; 1 12d4: 28 17 cp r18, r24 12d6: 39 07 cpc r19, r25 12d8: 34 f3 brlt .-52 ; 0x12a6 qp->message[i] = qp->message[i+1]; qp->number--; 12da: 80 91 c9 01 lds r24, 0x01C9 12de: 81 50 subi r24, 0x01 ; 1 12e0: 80 93 c9 01 sts 0x01C9, r24 12e4: cd cf rjmp .-102 ; 0x1280 block->ptr = data+(currentBlocks*BLOCKSIZE); ptr = (char*) block->ptr; //leave if theres not enough memory if (block->ptr == 0 || (uint16_t) block->ptr > HEAPSTART) { SREG = sregsys; 12e6: 80 91 0a 01 lds r24, 0x010A 12ea: 8f bf out 0x3f, r24 ; 63 12ec: c0 e0 ldi r28, 0x00 ; 0 12ee: d0 e0 ldi r29, 0x00 ; 0 12f0: 9b cf rjmp .-202 ; 0x1228 //**************************************************** #ifdef TASK_USE_ANHILATE uint8_t task_anhilate(Task *t) { sregsys=SREG; 12f2: 8f b7 in r24, 0x3f ; 63 12f4: 80 93 0a 01 sts 0x010A, r24 cli(); 12f8: f8 94 cli #ifdef TASK_USE_SEMAPHORE //uint8_t *s = (uint8_t*) Semaphore; //uint8_t i; #endif uint8_t ID = t->ID; 12fa: 10 91 ce 01 lds r17, 0x01CE if (ID > NUMBER || ID == 0) 12fe: 81 2f mov r24, r17 1300: 81 50 subi r24, 0x01 ; 1 1302: 80 31 cpi r24, 0x10 ; 16 1304: 80 f5 brcc .+96 ; 0x1366 SREG=sregsys; return 0; } a=ID; //reset task values if (ID == currentTask) 1306: 61 2f mov r22, r17 1308: 70 e0 ldi r23, 0x00 ; 0 130a: 80 91 00 01 lds r24, 0x0100 130e: 99 27 eor r25, r25 1310: 87 fd sbrc r24, 7 1312: 90 95 com r25 1314: 68 17 cp r22, r24 1316: 79 07 cpc r23, r25 1318: 21 f4 brne .+8 ; 0x1322 current = 0; //to avoid problems when deleting the current task 131a: 10 92 09 01 sts 0x0109, r1 131e: 10 92 08 01 sts 0x0108, r1 tasks[a] = 0; //this deletes the task 1322: fb 01 movw r30, r22 1324: ee 0f add r30, r30 1326: ff 1f adc r31, r31 1328: ea 5e subi r30, 0xEA ; 234 132a: fe 4f sbci r31, 0xFE ; 254 132c: 11 82 std Z+1, r1 ; 0x01 132e: 10 82 st Z, r1 #ifdef TASK_USE_MEM //release task memory blocks //no reason to clear it here, because theres a clearing in memory_allocate_block() for (a=0;a 1338: 50 e0 ldi r21, 0x00 ; 0 { if ((blocks+a)->owner == ID) 133a: 03 e0 ldi r16, 0x03 ; 3 133c: 50 9f mul r21, r16 133e: f0 01 movw r30, r0 1340: 11 24 eor r1, r1 1342: e0 5f subi r30, 0xF0 ; 240 1344: fe 4f sbci r31, 0xFE ; 254 1346: 80 81 ld r24, Z 1348: 18 17 cp r17, r24 134a: 89 f0 breq .+34 ; 0x136e tasks[a] = 0; //this deletes the task #ifdef TASK_USE_MEM //release task memory blocks //no reason to clear it here, because theres a clearing in memory_allocate_block() for (a=0;a // *s = 0; // s++; // } #endif if (ID != currentTask) 1356: 80 91 00 01 lds r24, 0x0100 135a: 99 27 eor r25, r25 135c: 87 fd sbrc r24, 7 135e: 90 95 com r25 1360: 68 17 cp r22, r24 1362: 79 07 cpc r23, r25 1364: b1 f1 breq .+108 ; 0x13d2 { //go back to parent task SREG=sregsys; 1366: 80 91 0a 01 lds r24, 0x010A 136a: 8f bf out 0x3f, r24 ; 63 136c: 2a cf rjmp .-428 ; 0x11c2 //no reason to clear it here, because theres a clearing in memory_allocate_block() for (a=0;aowner == ID) { (blocks+a)->ptr=0; 136e: 12 82 std Z+2, r1 ; 0x02 1370: 11 82 std Z+1, r1 ; 0x01 (blocks+a)->owner=0; 1372: 10 82 st Z, r1 for (b=a;b<(currentBlocks-1);b++) 1374: 25 2f mov r18, r21 1376: 30 e0 ldi r19, 0x00 ; 0 1378: 80 91 0b 01 lds r24, 0x010B 137c: 90 e0 ldi r25, 0x00 ; 0 137e: 01 97 sbiw r24, 0x01 ; 1 1380: 28 17 cp r18, r24 1382: 39 07 cpc r19, r25 1384: 04 f5 brge .+64 ; 0x13c6 1386: 45 2f mov r20, r21 blocks[b]=blocks[b+1]; 1388: c9 01 movw r24, r18 138a: 01 96 adiw r24, 0x01 ; 1 138c: d9 01 movw r26, r18 138e: aa 0f add r26, r26 1390: bb 1f adc r27, r27 1392: a2 0f add r26, r18 1394: b3 1f adc r27, r19 1396: fc 01 movw r30, r24 1398: ee 0f add r30, r30 139a: ff 1f adc r31, r31 139c: e8 0f add r30, r24 139e: f9 1f adc r31, r25 13a0: a0 5f subi r26, 0xF0 ; 240 13a2: be 4f sbci r27, 0xFE ; 254 13a4: e0 5f subi r30, 0xF0 ; 240 13a6: fe 4f sbci r31, 0xFE ; 254 13a8: 83 e0 ldi r24, 0x03 ; 3 13aa: 01 90 ld r0, Z+ 13ac: 0d 92 st X+, r0 13ae: 81 50 subi r24, 0x01 ; 1 13b0: e1 f7 brne .-8 ; 0x13aa { if ((blocks+a)->owner == ID) { (blocks+a)->ptr=0; (blocks+a)->owner=0; for (b=a;b<(currentBlocks-1);b++) 13b2: 4f 5f subi r20, 0xFF ; 255 13b4: 24 2f mov r18, r20 13b6: 30 e0 ldi r19, 0x00 ; 0 13b8: 80 91 0b 01 lds r24, 0x010B 13bc: 90 e0 ldi r25, 0x00 ; 0 13be: 01 97 sbiw r24, 0x01 ; 1 13c0: 28 17 cp r18, r24 13c2: 39 07 cpc r19, r25 13c4: 0c f3 brlt .-62 ; 0x1388 blocks[b]=blocks[b+1]; currentBlocks--; 13c6: 80 91 0b 01 lds r24, 0x010B 13ca: 81 50 subi r24, 0x01 ; 1 13cc: 80 93 0b 01 sts 0x010B, r24 13d0: bd cf rjmp .-134 ; 0x134c return TRUE; } else { //switch to next task without going back to the deleted task if it's the parent task TIMER_REG = _BV(CS00); 13d2: 81 e0 ldi r24, 0x01 ; 1 13d4: 85 bd out 0x25, r24 ; 37 TCNT0 = 0xFF; 13d6: 8f ef ldi r24, 0xFF ; 255 13d8: 86 bd out 0x26, r24 ; 38 currentTask = -1; 13da: 80 93 00 01 sts 0x0100, r24 set_sleep_mode(SLEEP_MODE_IDLE); 13de: 83 b7 in r24, 0x33 ; 51 13e0: 81 7f andi r24, 0xF1 ; 241 13e2: 83 bf out 0x33, r24 ; 51 sei(); 13e4: 78 94 sei sleep_mode(); 13e6: 83 b7 in r24, 0x33 ; 51 13e8: 81 60 ori r24, 0x01 ; 1 13ea: 83 bf out 0x33, r24 ; 51 13ec: 88 95 sleep 13ee: 83 b7 in r24, 0x33 ; 51 13f0: 8e 7f andi r24, 0xFE ; 254 13f2: 83 bf out 0x33, r24 ; 51 13f4: e6 ce rjmp .-564 ; 0x11c2 000013f6 : //+++Task functions+++ //this is the display task for the minutes void display_minutes() { 13f6: 0f 93 push r16 13f8: 1f 93 push r17 13fa: cf 93 push r28 13fc: df 93 push r29 //* output: free places in the queue * //**************************************************** uint8_t queue_exists(Queue *qp) { if (qp->queueDepth) 13fe: 80 91 14 02 lds r24, 0x0214 1402: 88 23 and r24, r24 1404: 09 f4 brne .+2 ; 0x1408 1406: 9d c0 rjmp .+314 ; 0x1542 //* description: check if memory is available * //* input: no * //* output: number of free memory blocks * //**************************************************** uint8_t memory_get_free_blocks() {return MAXBLOCKS - currentBlocks;} 1408: 80 91 0b 01 lds r24, 0x010B if (!(queue_exists(&minutes_queue)) || !(memory_get_free_blocks())) 140c: 82 30 cpi r24, 0x02 ; 2 140e: 09 f4 brne .+2 ; 0x1412 1410: 98 c0 rjmp .+304 ; 0x1542 //* output: pointer to memory block or 0 (error) * //**************************************************** void* memory_allocate_block() { sregsys = SREG; 1412: 8f b7 in r24, 0x3f ; 63 1414: 80 93 0a 01 sts 0x010A, r24 cli(); 1418: f8 94 cli if (currentBlocks >= MAXBLOCKS) 141a: 80 91 0b 01 lds r24, 0x010B 141e: 82 30 cpi r24, 0x02 ; 2 1420: 08 f0 brcs .+2 ; 0x1424 1422: 89 c0 rjmp .+274 ; 0x1536 SREG = sregsys; return 0; } uint8_t a; char* ptr; mem_block_intern* block = (blocks+currentBlocks); 1424: 90 91 0b 01 lds r25, 0x010B 1428: 83 e0 ldi r24, 0x03 ; 3 142a: 98 9f mul r25, r24 142c: f0 01 movw r30, r0 142e: 11 24 eor r1, r1 1430: e0 5f subi r30, 0xF0 ; 240 1432: fe 4f sbci r31, 0xFE ; 254 //insert block //set a pointer to the memory block block->ptr = data+(currentBlocks*BLOCKSIZE); 1434: 80 91 0b 01 lds r24, 0x010B 1438: 90 e0 ldi r25, 0x00 ; 0 143a: 82 5f subi r24, 0xF2 ; 242 143c: 9e 4f sbci r25, 0xFE ; 254 143e: 92 83 std Z+2, r25 ; 0x02 1440: 81 83 std Z+1, r24 ; 0x01 ptr = (char*) block->ptr; 1442: a1 81 ldd r26, Z+1 ; 0x01 1444: b2 81 ldd r27, Z+2 ; 0x02 //leave if theres not enough memory if (block->ptr == 0 || (uint16_t) block->ptr > HEAPSTART) 1446: 81 81 ldd r24, Z+1 ; 0x01 1448: 92 81 ldd r25, Z+2 ; 0x02 144a: 89 2b or r24, r25 144c: 09 f4 brne .+2 ; 0x1450 144e: 73 c0 rjmp .+230 ; 0x1536 1450: 81 81 ldd r24, Z+1 ; 0x01 1452: 92 81 ldd r25, Z+2 ; 0x02 1454: 80 50 subi r24, 0x00 ; 0 1456: 93 40 sbci r25, 0x03 ; 3 1458: 08 f0 brcs .+2 ; 0x145c 145a: 6d c0 rjmp .+218 ; 0x1536 SREG = sregsys; return 0; } //clear memory for (a=0;aowner = currentTask; 145e: 80 91 00 01 lds r24, 0x0100 1462: 80 83 st Z, r24 currentBlocks++; 1464: 80 91 0b 01 lds r24, 0x010B 1468: 8f 5f subi r24, 0xFF ; 255 146a: 80 93 0b 01 sts 0x010B, r24 SREG = sregsys; 146e: 80 91 0a 01 lds r24, 0x010A 1472: 8f bf out 0x3f, r24 ; 63 //return pointer to memory block return (void*) block->ptr; 1474: c1 81 ldd r28, Z+1 ; 0x01 1476: d2 81 ldd r29, Z+2 ; 0x02 //**************************************************** uint8_t queue_wait_for_message(Queue *qp) { //enable multitasking to avoid a deadrun wdt_enable(WDTO_2S); 1478: 08 e1 ldi r16, 0x18 ; 24 147a: 10 e0 ldi r17, 0x00 ; 0 147c: 7f e0 ldi r23, 0x0F ; 15 TIMER_ENABLE |= _BV(TOIE0); sei(); if (qp->queueDepth == 0) return 0; while (qp->number == 0) TCNT0=0xFF; 147e: 5f ef ldi r21, 0xFF ; 255 //**************************************************** uint8_t queue_wait_for_message(Queue *qp) { //enable multitasking to avoid a deadrun wdt_enable(WDTO_2S); 1480: 0f b6 in r0, 0x3f ; 63 1482: f8 94 cli 1484: a8 95 wdr 1486: 00 93 60 00 sts 0x0060, r16 148a: 0f be out 0x3f, r0 ; 63 148c: 70 93 60 00 sts 0x0060, r23 TIMER_ENABLE |= _BV(TOIE0); 1490: 80 91 6e 00 lds r24, 0x006E 1494: 81 60 ori r24, 0x01 ; 1 1496: 80 93 6e 00 sts 0x006E, r24 sei(); 149a: 78 94 sei if (qp->queueDepth == 0) 149c: 80 91 14 02 lds r24, 0x0214 14a0: 88 23 and r24, r24 14a2: 11 f4 brne .+4 ; 0x14a8 14a4: 05 c0 rjmp .+10 ; 0x14b0 return 0; while (qp->number == 0) TCNT0=0xFF; 14a6: 56 bd out 0x26, r21 ; 38 wdt_enable(WDTO_2S); TIMER_ENABLE |= _BV(TOIE0); sei(); if (qp->queueDepth == 0) return 0; while (qp->number == 0) 14a8: 80 91 15 02 lds r24, 0x0215 14ac: 88 23 and r24, r24 14ae: d9 f3 breq .-10 ; 0x14a6 //* * //*********************************************************************** unsigned char queue_read_byte(Queue *qp, uint8_t position, uint8_t delete_message) { sregsys = SREG; 14b0: 8f b7 in r24, 0x3f ; 63 14b2: 80 93 0a 01 sts 0x010A, r24 cli(); 14b6: f8 94 cli uint8_t i; unsigned char tempmsg; if (qp->number == 0 || qp->number <= position || qp->item_size != 1) 14b8: 80 91 15 02 lds r24, 0x0215 14bc: 88 23 and r24, r24 14be: 41 f0 breq .+16 ; 0x14d0 14c0: 80 91 15 02 lds r24, 0x0215 14c4: 88 23 and r24, r24 14c6: 21 f0 breq .+8 ; 0x14d0 14c8: 80 91 13 02 lds r24, 0x0213 14cc: 81 30 cpi r24, 0x01 ; 1 14ce: 31 f0 breq .+12 ; 0x14dc //re-organize message queue (FIFO) for (i=position;i<(qp->number)-1;i++) qp->message[i] = qp->message[i+1]; qp->number--; } SREG = sregsys; 14d0: 80 91 0a 01 lds r24, 0x010A 14d4: 8f bf out 0x3f, r24 ; 63 while (1) { //Wait for new minute message queue_wait_for_message(&minutes_queue); //set PORTD to new minute value *min_ptr = queue_read_byte(&minutes_queue,0,1); 14d6: 68 83 st Y, r22 PORTD = *min_ptr; 14d8: 6b b9 out 0x0b, r22 ; 11 14da: d2 cf rjmp .-92 ; 0x1480 { SREG = sregsys; return; } //read message tempmsg = qp->message[position]; 14dc: e0 91 18 02 lds r30, 0x0218 14e0: f0 91 19 02 lds r31, 0x0219 14e4: 60 81 ld r22, Z if (delete_message) { //re-organize message queue (FIFO) for (i=position;i<(qp->number)-1;i++) 14e6: 80 91 15 02 lds r24, 0x0215 14ea: 90 e0 ldi r25, 0x00 ; 0 14ec: 02 97 sbiw r24, 0x02 ; 2 14ee: ec f0 brlt .+58 ; 0x152a 14f0: 40 e0 ldi r20, 0x00 ; 0 14f2: 20 e0 ldi r18, 0x00 ; 0 14f4: 30 e0 ldi r19, 0x00 ; 0 qp->message[i] = qp->message[i+1]; 14f6: a0 91 18 02 lds r26, 0x0218 14fa: b0 91 19 02 lds r27, 0x0219 14fe: a2 0f add r26, r18 1500: b3 1f adc r27, r19 1502: e0 91 18 02 lds r30, 0x0218 1506: f0 91 19 02 lds r31, 0x0219 150a: 2f 5f subi r18, 0xFF ; 255 150c: 3f 4f sbci r19, 0xFF ; 255 150e: e2 0f add r30, r18 1510: f3 1f adc r31, r19 1512: 80 81 ld r24, Z 1514: 8c 93 st X, r24 //read message tempmsg = qp->message[position]; if (delete_message) { //re-organize message queue (FIFO) for (i=position;i<(qp->number)-1;i++) 1516: 4f 5f subi r20, 0xFF ; 255 1518: 80 91 15 02 lds r24, 0x0215 151c: 24 2f mov r18, r20 151e: 30 e0 ldi r19, 0x00 ; 0 1520: 90 e0 ldi r25, 0x00 ; 0 1522: 01 97 sbiw r24, 0x01 ; 1 1524: 28 17 cp r18, r24 1526: 39 07 cpc r19, r25 1528: 34 f3 brlt .-52 ; 0x14f6 qp->message[i] = qp->message[i+1]; qp->number--; 152a: 80 91 15 02 lds r24, 0x0215 152e: 81 50 subi r24, 0x01 ; 1 1530: 80 93 15 02 sts 0x0215, r24 1534: cd cf rjmp .-102 ; 0x14d0 block->ptr = data+(currentBlocks*BLOCKSIZE); ptr = (char*) block->ptr; //leave if theres not enough memory if (block->ptr == 0 || (uint16_t) block->ptr > HEAPSTART) { SREG = sregsys; 1536: 80 91 0a 01 lds r24, 0x010A 153a: 8f bf out 0x3f, r24 ; 63 153c: c0 e0 ldi r28, 0x00 ; 0 153e: d0 e0 ldi r29, 0x00 ; 0 1540: 9b cf rjmp .-202 ; 0x1478 //**************************************************** #ifdef TASK_USE_ANHILATE uint8_t task_anhilate(Task *t) { sregsys=SREG; 1542: 8f b7 in r24, 0x3f ; 63 1544: 80 93 0a 01 sts 0x010A, r24 cli(); 1548: f8 94 cli #ifdef TASK_USE_SEMAPHORE //uint8_t *s = (uint8_t*) Semaphore; //uint8_t i; #endif uint8_t ID = t->ID; 154a: 10 91 82 01 lds r17, 0x0182 if (ID > NUMBER || ID == 0) 154e: 81 2f mov r24, r17 1550: 81 50 subi r24, 0x01 ; 1 1552: 80 31 cpi r24, 0x10 ; 16 1554: 80 f5 brcc .+96 ; 0x15b6 SREG=sregsys; return 0; } a=ID; //reset task values if (ID == currentTask) 1556: 61 2f mov r22, r17 1558: 70 e0 ldi r23, 0x00 ; 0 155a: 80 91 00 01 lds r24, 0x0100 155e: 99 27 eor r25, r25 1560: 87 fd sbrc r24, 7 1562: 90 95 com r25 1564: 68 17 cp r22, r24 1566: 79 07 cpc r23, r25 1568: 21 f4 brne .+8 ; 0x1572 current = 0; //to avoid problems when deleting the current task 156a: 10 92 09 01 sts 0x0109, r1 156e: 10 92 08 01 sts 0x0108, r1 tasks[a] = 0; //this deletes the task 1572: fb 01 movw r30, r22 1574: ee 0f add r30, r30 1576: ff 1f adc r31, r31 1578: ea 5e subi r30, 0xEA ; 234 157a: fe 4f sbci r31, 0xFE ; 254 157c: 11 82 std Z+1, r1 ; 0x01 157e: 10 82 st Z, r1 #ifdef TASK_USE_MEM //release task memory blocks //no reason to clear it here, because theres a clearing in memory_allocate_block() for (a=0;a 1588: 50 e0 ldi r21, 0x00 ; 0 { if ((blocks+a)->owner == ID) 158a: 03 e0 ldi r16, 0x03 ; 3 158c: 50 9f mul r21, r16 158e: f0 01 movw r30, r0 1590: 11 24 eor r1, r1 1592: e0 5f subi r30, 0xF0 ; 240 1594: fe 4f sbci r31, 0xFE ; 254 1596: 80 81 ld r24, Z 1598: 18 17 cp r17, r24 159a: 89 f0 breq .+34 ; 0x15be tasks[a] = 0; //this deletes the task #ifdef TASK_USE_MEM //release task memory blocks //no reason to clear it here, because theres a clearing in memory_allocate_block() for (a=0;a // *s = 0; // s++; // } #endif if (ID != currentTask) 15a6: 80 91 00 01 lds r24, 0x0100 15aa: 99 27 eor r25, r25 15ac: 87 fd sbrc r24, 7 15ae: 90 95 com r25 15b0: 68 17 cp r22, r24 15b2: 79 07 cpc r23, r25 15b4: b1 f1 breq .+108 ; 0x1622 { //go back to parent task SREG=sregsys; 15b6: 80 91 0a 01 lds r24, 0x010A 15ba: 8f bf out 0x3f, r24 ; 63 15bc: 2a cf rjmp .-428 ; 0x1412 //no reason to clear it here, because theres a clearing in memory_allocate_block() for (a=0;aowner == ID) { (blocks+a)->ptr=0; 15be: 12 82 std Z+2, r1 ; 0x02 15c0: 11 82 std Z+1, r1 ; 0x01 (blocks+a)->owner=0; 15c2: 10 82 st Z, r1 for (b=a;b<(currentBlocks-1);b++) 15c4: 25 2f mov r18, r21 15c6: 30 e0 ldi r19, 0x00 ; 0 15c8: 80 91 0b 01 lds r24, 0x010B 15cc: 90 e0 ldi r25, 0x00 ; 0 15ce: 01 97 sbiw r24, 0x01 ; 1 15d0: 28 17 cp r18, r24 15d2: 39 07 cpc r19, r25 15d4: 04 f5 brge .+64 ; 0x1616 15d6: 45 2f mov r20, r21 blocks[b]=blocks[b+1]; 15d8: c9 01 movw r24, r18 15da: 01 96 adiw r24, 0x01 ; 1 15dc: d9 01 movw r26, r18 15de: aa 0f add r26, r26 15e0: bb 1f adc r27, r27 15e2: a2 0f add r26, r18 15e4: b3 1f adc r27, r19 15e6: fc 01 movw r30, r24 15e8: ee 0f add r30, r30 15ea: ff 1f adc r31, r31 15ec: e8 0f add r30, r24 15ee: f9 1f adc r31, r25 15f0: a0 5f subi r26, 0xF0 ; 240 15f2: be 4f sbci r27, 0xFE ; 254 15f4: e0 5f subi r30, 0xF0 ; 240 15f6: fe 4f sbci r31, 0xFE ; 254 15f8: 83 e0 ldi r24, 0x03 ; 3 15fa: 01 90 ld r0, Z+ 15fc: 0d 92 st X+, r0 15fe: 81 50 subi r24, 0x01 ; 1 1600: e1 f7 brne .-8 ; 0x15fa { if ((blocks+a)->owner == ID) { (blocks+a)->ptr=0; (blocks+a)->owner=0; for (b=a;b<(currentBlocks-1);b++) 1602: 4f 5f subi r20, 0xFF ; 255 1604: 24 2f mov r18, r20 1606: 30 e0 ldi r19, 0x00 ; 0 1608: 80 91 0b 01 lds r24, 0x010B 160c: 90 e0 ldi r25, 0x00 ; 0 160e: 01 97 sbiw r24, 0x01 ; 1 1610: 28 17 cp r18, r24 1612: 39 07 cpc r19, r25 1614: 0c f3 brlt .-62 ; 0x15d8 blocks[b]=blocks[b+1]; currentBlocks--; 1616: 80 91 0b 01 lds r24, 0x010B 161a: 81 50 subi r24, 0x01 ; 1 161c: 80 93 0b 01 sts 0x010B, r24 1620: bd cf rjmp .-134 ; 0x159c return TRUE; } else { //switch to next task without going back to the deleted task if it's the parent task TIMER_REG = _BV(CS00); 1622: 81 e0 ldi r24, 0x01 ; 1 1624: 85 bd out 0x25, r24 ; 37 TCNT0 = 0xFF; 1626: 8f ef ldi r24, 0xFF ; 255 1628: 86 bd out 0x26, r24 ; 38 currentTask = -1; 162a: 80 93 00 01 sts 0x0100, r24 set_sleep_mode(SLEEP_MODE_IDLE); 162e: 83 b7 in r24, 0x33 ; 51 1630: 81 7f andi r24, 0xF1 ; 241 1632: 83 bf out 0x33, r24 ; 51 sei(); 1634: 78 94 sei sleep_mode(); 1636: 83 b7 in r24, 0x33 ; 51 1638: 81 60 ori r24, 0x01 ; 1 163a: 83 bf out 0x33, r24 ; 51 163c: 88 95 sleep 163e: 83 b7 in r24, 0x33 ; 51 1640: 8e 7f andi r24, 0xFE ; 254 1642: 83 bf out 0x33, r24 ; 51 1644: e6 ce rjmp .-564 ; 0x1412 00001646 <__vector_16>: #endif //+++++++++++++++++++++Signal-Handler++++++++++++++++++ SIGNAL (SIG_OVERFLOW0) { 1646: 1f 92 push r1 1648: 0f 92 push r0 164a: 0f b6 in r0, 0x3f ; 63 164c: 0f 92 push r0 164e: 11 24 eor r1, r1 1650: 8f 93 push r24 1652: 9f 93 push r25 1654: ef 93 push r30 1656: ff 93 push r31 //**************************************************** void scheduler() { //save R0-31 to current->stack PUSH(31);PUSH(30);PUSH(29);PUSH(28);PUSH(27);PUSH(26);PUSH(25);PUSH(24); 1658: ff 93 push r31 165a: ef 93 push r30 165c: df 93 push r29 165e: cf 93 push r28 1660: bf 93 push r27 1662: af 93 push r26 1664: 9f 93 push r25 1666: 8f 93 push r24 PUSH(23);PUSH(22);PUSH(21);PUSH(20);PUSH(19);PUSH(18);PUSH(17);PUSH(16); 1668: 7f 93 push r23 166a: 6f 93 push r22 166c: 5f 93 push r21 166e: 4f 93 push r20 1670: 3f 93 push r19 1672: 2f 93 push r18 1674: 1f 93 push r17 1676: 0f 93 push r16 PUSH(15);PUSH(14);PUSH(13);PUSH(12);PUSH(11);PUSH(10);PUSH( 9);PUSH( 8); 1678: ff 92 push r15 167a: ef 92 push r14 167c: df 92 push r13 167e: cf 92 push r12 1680: bf 92 push r11 1682: af 92 push r10 1684: 9f 92 push r9 1686: 8f 92 push r8 PUSH( 7);PUSH( 6);PUSH( 5);PUSH( 4);PUSH( 3);PUSH( 2);PUSH( 1);PUSH( 0); 1688: 7f 92 push r7 168a: 6f 92 push r6 168c: 5f 92 push r5 168e: 4f 92 push r4 1690: 3f 92 push r3 1692: 2f 92 push r2 1694: 1f 92 push r1 1696: 0f 92 push r0 TIMER_REG = CLK1024; 1698: 85 e0 ldi r24, 0x05 ; 5 169a: 85 bd out 0x25, r24 ; 37 //save SREG and SP if (currentTask >= 0) 169c: 80 91 00 01 lds r24, 0x0100 16a0: 87 fd sbrc r24, 7 16a2: 17 c0 rjmp .+46 ; 0x16d2 <__vector_16+0x8c> { current = tasks[currentTask]; 16a4: e0 91 00 01 lds r30, 0x0100 16a8: ff 27 eor r31, r31 16aa: e7 fd sbrc r30, 7 16ac: f0 95 com r31 16ae: ee 0f add r30, r30 16b0: ff 1f adc r31, r31 16b2: ea 5e subi r30, 0xEA ; 234 16b4: fe 4f sbci r31, 0xFE ; 254 16b6: 01 90 ld r0, Z+ 16b8: f0 81 ld r31, Z 16ba: e0 2d mov r30, r0 16bc: f0 93 09 01 sts 0x0109, r31 16c0: e0 93 08 01 sts 0x0108, r30 current->sreg = SREG; 16c4: 8f b7 in r24, 0x3f ; 63 16c6: 81 83 std Z+1, r24 ; 0x01 current->sp = (unsigned char *)(SP + 32); 16c8: 8d b7 in r24, 0x3d ; 61 16ca: 9e b7 in r25, 0x3e ; 62 16cc: 80 96 adiw r24, 0x20 ; 32 16ce: 93 83 std Z+3, r25 ; 0x03 16d0: 82 83 std Z+2, r24 ; 0x02 } //switch to next task do { currentTask++; 16d2: 80 91 00 01 lds r24, 0x0100 16d6: 8f 5f subi r24, 0xFF ; 255 16d8: 80 93 00 01 sts 0x0100, r24 if (currentTask >= NUMBER) 16dc: 80 91 00 01 lds r24, 0x0100 16e0: 80 31 cpi r24, 0x10 ; 16 16e2: 14 f0 brlt .+4 ; 0x16e8 <__vector_16+0xa2> { currentTask = 0; 16e4: 10 92 00 01 sts 0x0100, r1 } current = tasks[currentTask]; 16e8: e0 91 00 01 lds r30, 0x0100 16ec: ff 27 eor r31, r31 16ee: e7 fd sbrc r30, 7 16f0: f0 95 com r31 16f2: ee 0f add r30, r30 16f4: ff 1f adc r31, r31 16f6: ea 5e subi r30, 0xEA ; 234 16f8: fe 4f sbci r31, 0xFE ; 254 16fa: 01 90 ld r0, Z+ 16fc: f0 81 ld r31, Z 16fe: e0 2d mov r30, r0 } #ifdef TASK_USE_SIGNAL while (!(current && current->state==TaskStateActive)); #else while (!current); 1700: 30 97 sbiw r30, 0x00 ; 0 1702: 39 f3 breq .-50 ; 0x16d2 <__vector_16+0x8c> 1704: f0 93 09 01 sts 0x0109, r31 1708: e0 93 08 01 sts 0x0108, r30 #endif //restore this task (SREG, SP and R0...31) if (current) { TCNT0 = current->prio; 170c: 84 81 ldd r24, Z+4 ; 0x04 170e: 86 bd out 0x26, r24 ; 38 SREG = current->sreg; 1710: 81 81 ldd r24, Z+1 ; 0x01 1712: 8f bf out 0x3f, r24 ; 63 SP = (unsigned int)(current->sp - 32); 1714: 82 81 ldd r24, Z+2 ; 0x02 1716: 93 81 ldd r25, Z+3 ; 0x03 1718: 80 97 sbiw r24, 0x20 ; 32 171a: 9e bf out 0x3e, r25 ; 62 171c: 8d bf out 0x3d, r24 ; 61 } POP( 0);POP( 1);POP( 2);POP( 3);POP( 4);POP( 5);POP( 6);POP( 7); 171e: 0f 90 pop r0 1720: 1f 90 pop r1 1722: 2f 90 pop r2 1724: 3f 90 pop r3 1726: 4f 90 pop r4 1728: 5f 90 pop r5 172a: 6f 90 pop r6 172c: 7f 90 pop r7 POP( 8);POP( 9);POP(10);POP(11);POP(12);POP(13);POP(14);POP(15); 172e: 8f 90 pop r8 1730: 9f 90 pop r9 1732: af 90 pop r10 1734: bf 90 pop r11 1736: cf 90 pop r12 1738: df 90 pop r13 173a: ef 90 pop r14 173c: ff 90 pop r15 POP(16);POP(17);POP(18);POP(19);POP(20);POP(21);POP(22);POP(23); 173e: 0f 91 pop r16 1740: 1f 91 pop r17 1742: 2f 91 pop r18 1744: 3f 91 pop r19 1746: 4f 91 pop r20 1748: 5f 91 pop r21 174a: 6f 91 pop r22 174c: 7f 91 pop r23 POP(24);POP(25);POP(26);POP(27);POP(28);POP(29);POP(30);POP(31); 174e: 8f 91 pop r24 1750: 9f 91 pop r25 1752: af 91 pop r26 1754: bf 91 pop r27 1756: cf 91 pop r28 1758: df 91 pop r29 175a: ef 91 pop r30 175c: ff 91 pop r31 asm volatile("reti"); 175e: 18 95 reti scheduler(); } 1760: ff 91 pop r31 1762: ef 91 pop r30 1764: 9f 91 pop r25 1766: 8f 91 pop r24 1768: 0f 90 pop r0 176a: 0f be out 0x3f, r0 ; 63 176c: 0f 90 pop r0 176e: 1f 90 pop r1 1770: 18 95 reti 00001772 <__udivmodqi4>: 1772: 99 1b sub r25, r25 1774: 79 e0 ldi r23, 0x09 ; 9 1776: 04 c0 rjmp .+8 ; 0x1780 <__udivmodqi4_ep> 00001778 <__udivmodqi4_loop>: 1778: 99 1f adc r25, r25 177a: 96 17 cp r25, r22 177c: 08 f0 brcs .+2 ; 0x1780 <__udivmodqi4_ep> 177e: 96 1b sub r25, r22 00001780 <__udivmodqi4_ep>: 1780: 88 1f adc r24, r24 1782: 7a 95 dec r23 1784: c9 f7 brne .-14 ; 0x1778 <__udivmodqi4_loop> 1786: 80 95 com r24 1788: 08 95 ret 0000178a : 178a: cf 93 push r28 178c: df 93 push r29 178e: bc 01 movw r22, r24 1790: 82 30 cpi r24, 0x02 ; 2 1792: 91 05 cpc r25, r1 1794: 10 f4 brcc .+4 ; 0x179a 1796: 62 e0 ldi r22, 0x02 ; 2 1798: 70 e0 ldi r23, 0x00 ; 0 179a: a0 91 1c 02 lds r26, 0x021C 179e: b0 91 1d 02 lds r27, 0x021D 17a2: ed 01 movw r28, r26 17a4: e0 e0 ldi r30, 0x00 ; 0 17a6: f0 e0 ldi r31, 0x00 ; 0 17a8: 40 e0 ldi r20, 0x00 ; 0 17aa: 50 e0 ldi r21, 0x00 ; 0 17ac: 21 c0 rjmp .+66 ; 0x17f0 17ae: 88 81 ld r24, Y 17b0: 99 81 ldd r25, Y+1 ; 0x01 17b2: 86 17 cp r24, r22 17b4: 97 07 cpc r25, r23 17b6: 69 f4 brne .+26 ; 0x17d2 17b8: 8a 81 ldd r24, Y+2 ; 0x02 17ba: 9b 81 ldd r25, Y+3 ; 0x03 17bc: 30 97 sbiw r30, 0x00 ; 0 17be: 19 f0 breq .+6 ; 0x17c6 17c0: 93 83 std Z+3, r25 ; 0x03 17c2: 82 83 std Z+2, r24 ; 0x02 17c4: 04 c0 rjmp .+8 ; 0x17ce 17c6: 90 93 1d 02 sts 0x021D, r25 17ca: 80 93 1c 02 sts 0x021C, r24 17ce: fe 01 movw r30, r28 17d0: 34 c0 rjmp .+104 ; 0x183a 17d2: 68 17 cp r22, r24 17d4: 79 07 cpc r23, r25 17d6: 38 f4 brcc .+14 ; 0x17e6 17d8: 41 15 cp r20, r1 17da: 51 05 cpc r21, r1 17dc: 19 f0 breq .+6 ; 0x17e4 17de: 84 17 cp r24, r20 17e0: 95 07 cpc r25, r21 17e2: 08 f4 brcc .+2 ; 0x17e6 17e4: ac 01 movw r20, r24 17e6: fe 01 movw r30, r28 17e8: 8a 81 ldd r24, Y+2 ; 0x02 17ea: 9b 81 ldd r25, Y+3 ; 0x03 17ec: 9c 01 movw r18, r24 17ee: e9 01 movw r28, r18 17f0: 20 97 sbiw r28, 0x00 ; 0 17f2: e9 f6 brne .-70 ; 0x17ae 17f4: 41 15 cp r20, r1 17f6: 51 05 cpc r21, r1 17f8: a9 f1 breq .+106 ; 0x1864 17fa: ca 01 movw r24, r20 17fc: 86 1b sub r24, r22 17fe: 97 0b sbc r25, r23 1800: 04 97 sbiw r24, 0x04 ; 4 1802: 08 f4 brcc .+2 ; 0x1806 1804: ba 01 movw r22, r20 1806: e0 e0 ldi r30, 0x00 ; 0 1808: f0 e0 ldi r31, 0x00 ; 0 180a: 2a c0 rjmp .+84 ; 0x1860 180c: 8d 91 ld r24, X+ 180e: 9c 91 ld r25, X 1810: 11 97 sbiw r26, 0x01 ; 1 1812: 84 17 cp r24, r20 1814: 95 07 cpc r25, r21 1816: f9 f4 brne .+62 ; 0x1856 1818: 64 17 cp r22, r20 181a: 75 07 cpc r23, r21 181c: 81 f4 brne .+32 ; 0x183e 181e: 12 96 adiw r26, 0x02 ; 2 1820: 8d 91 ld r24, X+ 1822: 9c 91 ld r25, X 1824: 13 97 sbiw r26, 0x03 ; 3 1826: 30 97 sbiw r30, 0x00 ; 0 1828: 19 f0 breq .+6 ; 0x1830 182a: 93 83 std Z+3, r25 ; 0x03 182c: 82 83 std Z+2, r24 ; 0x02 182e: 04 c0 rjmp .+8 ; 0x1838 1830: 90 93 1d 02 sts 0x021D, r25 1834: 80 93 1c 02 sts 0x021C, r24 1838: fd 01 movw r30, r26 183a: 32 96 adiw r30, 0x02 ; 2 183c: 4f c0 rjmp .+158 ; 0x18dc 183e: ca 01 movw r24, r20 1840: 86 1b sub r24, r22 1842: 97 0b sbc r25, r23 1844: fd 01 movw r30, r26 1846: e8 0f add r30, r24 1848: f9 1f adc r31, r25 184a: 61 93 st Z+, r22 184c: 71 93 st Z+, r23 184e: 02 97 sbiw r24, 0x02 ; 2 1850: 8d 93 st X+, r24 1852: 9c 93 st X, r25 1854: 43 c0 rjmp .+134 ; 0x18dc 1856: fd 01 movw r30, r26 1858: 82 81 ldd r24, Z+2 ; 0x02 185a: 93 81 ldd r25, Z+3 ; 0x03 185c: 9c 01 movw r18, r24 185e: d9 01 movw r26, r18 1860: 10 97 sbiw r26, 0x00 ; 0 1862: a1 f6 brne .-88 ; 0x180c 1864: 80 91 1a 02 lds r24, 0x021A 1868: 90 91 1b 02 lds r25, 0x021B 186c: 89 2b or r24, r25 186e: 41 f4 brne .+16 ; 0x1880 1870: 80 91 03 01 lds r24, 0x0103 1874: 90 91 04 01 lds r25, 0x0104 1878: 90 93 1b 02 sts 0x021B, r25 187c: 80 93 1a 02 sts 0x021A, r24 1880: 40 91 05 01 lds r20, 0x0105 1884: 50 91 06 01 lds r21, 0x0106 1888: 41 15 cp r20, r1 188a: 51 05 cpc r21, r1 188c: 41 f4 brne .+16 ; 0x189e 188e: 4d b7 in r20, 0x3d ; 61 1890: 5e b7 in r21, 0x3e ; 62 1892: 80 91 01 01 lds r24, 0x0101 1896: 90 91 02 01 lds r25, 0x0102 189a: 48 1b sub r20, r24 189c: 59 0b sbc r21, r25 189e: 20 91 1a 02 lds r18, 0x021A 18a2: 30 91 1b 02 lds r19, 0x021B 18a6: 24 17 cp r18, r20 18a8: 35 07 cpc r19, r21 18aa: b0 f4 brcc .+44 ; 0x18d8 18ac: ca 01 movw r24, r20 18ae: 82 1b sub r24, r18 18b0: 93 0b sbc r25, r19 18b2: 86 17 cp r24, r22 18b4: 97 07 cpc r25, r23 18b6: 80 f0 brcs .+32 ; 0x18d8 18b8: ab 01 movw r20, r22 18ba: 4e 5f subi r20, 0xFE ; 254 18bc: 5f 4f sbci r21, 0xFF ; 255 18be: 84 17 cp r24, r20 18c0: 95 07 cpc r25, r21 18c2: 50 f0 brcs .+20 ; 0x18d8 18c4: 42 0f add r20, r18 18c6: 53 1f adc r21, r19 18c8: 50 93 1b 02 sts 0x021B, r21 18cc: 40 93 1a 02 sts 0x021A, r20 18d0: f9 01 movw r30, r18 18d2: 61 93 st Z+, r22 18d4: 71 93 st Z+, r23 18d6: 02 c0 rjmp .+4 ; 0x18dc 18d8: e0 e0 ldi r30, 0x00 ; 0 18da: f0 e0 ldi r31, 0x00 ; 0 18dc: cf 01 movw r24, r30 18de: df 91 pop r29 18e0: cf 91 pop r28 18e2: 08 95 ret 000018e4 : 18e4: cf 93 push r28 18e6: df 93 push r29 18e8: 00 97 sbiw r24, 0x00 ; 0 18ea: 09 f4 brne .+2 ; 0x18ee 18ec: 50 c0 rjmp .+160 ; 0x198e 18ee: ec 01 movw r28, r24 18f0: 22 97 sbiw r28, 0x02 ; 2 18f2: 1b 82 std Y+3, r1 ; 0x03 18f4: 1a 82 std Y+2, r1 ; 0x02 18f6: a0 91 1c 02 lds r26, 0x021C 18fa: b0 91 1d 02 lds r27, 0x021D 18fe: 10 97 sbiw r26, 0x00 ; 0 1900: 09 f1 breq .+66 ; 0x1944 1902: 40 e0 ldi r20, 0x00 ; 0 1904: 50 e0 ldi r21, 0x00 ; 0 1906: ac 17 cp r26, r28 1908: bd 07 cpc r27, r29 190a: 08 f1 brcs .+66 ; 0x194e 190c: bb 83 std Y+3, r27 ; 0x03 190e: aa 83 std Y+2, r26 ; 0x02 1910: fe 01 movw r30, r28 1912: 21 91 ld r18, Z+ 1914: 31 91 ld r19, Z+ 1916: e2 0f add r30, r18 1918: f3 1f adc r31, r19 191a: ae 17 cp r26, r30 191c: bf 07 cpc r27, r31 191e: 79 f4 brne .+30 ; 0x193e 1920: 8d 91 ld r24, X+ 1922: 9c 91 ld r25, X 1924: 11 97 sbiw r26, 0x01 ; 1 1926: 28 0f add r18, r24 1928: 39 1f adc r19, r25 192a: 2e 5f subi r18, 0xFE ; 254 192c: 3f 4f sbci r19, 0xFF ; 255 192e: 39 83 std Y+1, r19 ; 0x01 1930: 28 83 st Y, r18 1932: 12 96 adiw r26, 0x02 ; 2 1934: 8d 91 ld r24, X+ 1936: 9c 91 ld r25, X 1938: 13 97 sbiw r26, 0x03 ; 3 193a: 9b 83 std Y+3, r25 ; 0x03 193c: 8a 83 std Y+2, r24 ; 0x02 193e: 41 15 cp r20, r1 1940: 51 05 cpc r21, r1 1942: 71 f4 brne .+28 ; 0x1960 1944: d0 93 1d 02 sts 0x021D, r29 1948: c0 93 1c 02 sts 0x021C, r28 194c: 20 c0 rjmp .+64 ; 0x198e 194e: 12 96 adiw r26, 0x02 ; 2 1950: 8d 91 ld r24, X+ 1952: 9c 91 ld r25, X 1954: 13 97 sbiw r26, 0x03 ; 3 1956: ad 01 movw r20, r26 1958: 00 97 sbiw r24, 0x00 ; 0 195a: 11 f0 breq .+4 ; 0x1960 195c: dc 01 movw r26, r24 195e: d3 cf rjmp .-90 ; 0x1906 1960: fa 01 movw r30, r20 1962: d3 83 std Z+3, r29 ; 0x03 1964: c2 83 std Z+2, r28 ; 0x02 1966: 21 91 ld r18, Z+ 1968: 31 91 ld r19, Z+ 196a: e2 0f add r30, r18 196c: f3 1f adc r31, r19 196e: ce 17 cp r28, r30 1970: df 07 cpc r29, r31 1972: 69 f4 brne .+26 ; 0x198e 1974: 88 81 ld r24, Y 1976: 99 81 ldd r25, Y+1 ; 0x01 1978: 28 0f add r18, r24 197a: 39 1f adc r19, r25 197c: 2e 5f subi r18, 0xFE ; 254 197e: 3f 4f sbci r19, 0xFF ; 255 1980: fa 01 movw r30, r20 1982: 31 83 std Z+1, r19 ; 0x01 1984: 20 83 st Z, r18 1986: 8a 81 ldd r24, Y+2 ; 0x02 1988: 9b 81 ldd r25, Y+3 ; 0x03 198a: 93 83 std Z+3, r25 ; 0x03 198c: 82 83 std Z+2, r24 ; 0x02 198e: df 91 pop r29 1990: cf 91 pop r28 1992: 08 95 ret 00001994 <_exit>: 1994: f8 94 cli 00001996 <__stop_program>: 1996: ff cf rjmp .-2 ; 0x1996 <__stop_program>