nano_os.elf: file format elf32-avr Sections: Idx Name Size VMA LMA File off Algn 0 .data 00000008 00800100 00000cf4 00000d88 2**0 CONTENTS, ALLOC, LOAD, DATA 1 .text 00000cf4 00000000 00000000 00000094 2**1 CONTENTS, ALLOC, LOAD, READONLY, CODE 2 .bss 00000116 00800108 00800108 00000d90 2**0 ALLOC 3 .stab 000006b4 00000000 00000000 00000d90 2**2 CONTENTS, READONLY, DEBUGGING 4 .stabstr 00000082 00000000 00000000 00001444 2**0 CONTENTS, READONLY, DEBUGGING 5 .debug_aranges 00000048 00000000 00000000 000014c6 2**0 CONTENTS, READONLY, DEBUGGING 6 .debug_pubnames 0000035c 00000000 00000000 0000150e 2**0 CONTENTS, READONLY, DEBUGGING 7 .debug_info 00000bee 00000000 00000000 0000186a 2**0 CONTENTS, READONLY, DEBUGGING 8 .debug_abbrev 0000041d 00000000 00000000 00002458 2**0 CONTENTS, READONLY, DEBUGGING 9 .debug_line 00000d9f 00000000 00000000 00002875 2**0 CONTENTS, READONLY, DEBUGGING 10 .debug_frame 00000220 00000000 00000000 00003614 2**2 CONTENTS, READONLY, DEBUGGING 11 .debug_str 00000530 00000000 00000000 00003834 2**0 CONTENTS, READONLY, DEBUGGING 12 .debug_loc 00000863 00000000 00000000 00003d64 2**0 CONTENTS, READONLY, DEBUGGING 13 .debug_ranges 00000020 00000000 00000000 000045c7 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 ae 03 jmp 0x75c ; 0x75c <__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 f1 03 jmp 0x7e2 ; 0x7e2 <__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 53 00 jmp 0xa6 ; 0xa6 <__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: e4 ef ldi r30, 0xF4 ; 244 7c: fc e0 ldi r31, 0x0C ; 12 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 12 05 call 0xa24 ; 0xa24
9e: 0c 94 78 06 jmp 0xcf0 ; 0xcf0 <_exit> 000000a2 <__bad_interrupt>: a2: 0c 94 00 00 jmp 0 ; 0x0 <__vectors> 000000a6 <__vector_16>: void TIMER_VECTOR() __attribute__ ( ( signal, naked ) ); ISR(TIMER_VECTOR) { //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 <__vector_16+0x7a> { 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 <__vector_16+0x90> { 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 <__vector_16+0x7a> 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 000001ae : //* Prio: Priority * //* output: none * //**************************************************** void task_create(Task *t, TaskFunction f, TaskPrio prio) { 1ae: cf 93 push r28 1b0: df 93 push r29 1b2: dc 01 movw r26, r24 sregsys = SREG; 1b4: 8f b7 in r24, 0x3f ; 63 1b6: 80 93 0a 01 sts 0x010A, r24 cli(); 1ba: f8 94 cli signed char a; unsigned char *s = (unsigned char *)(t->stack + sizeof(t->stack) - 3); 1bc: fd 01 movw r30, r26 1be: ee 5b subi r30, 0xBE ; 190 1c0: ff 4f sbci r31, 0xFF ; 255 1c2: 8f e1 ldi r24, 0x1F ; 31 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: e0 f7 brcc .-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: cd 01 movw r24, r26 1d4: 8e 5b subi r24, 0xBE ; 190 1d6: 9f 4f sbci r25, 0xFF ; 255 1d8: 13 96 adiw r26, 0x03 ; 3 1da: 9c 93 st X, r25 1dc: 8e 93 st -X, r24 1de: 12 97 sbiw r26, 0x02 ; 2 t->prio = prio; 1e0: 14 96 adiw r26, 0x04 ; 4 1e2: 4c 93 st X, r20 1e4: 14 97 sbiw r26, 0x04 ; 4 t->stack[sizeof(t->stack)-2] = ((unsigned int)f)>>8; 1e6: ad 5b subi r26, 0xBD ; 189 1e8: bf 4f sbci r27, 0xFF ; 255 1ea: 7d 93 st X+, r23 t->stack[sizeof(t->stack)-1] = ((unsigned int)f)&0xff; 1ec: 6c 93 st X, r22 1ee: a4 54 subi r26, 0x44 ; 68 1f0: b0 40 sbci r27, 0x00 ; 0 1f2: c6 e1 ldi r28, 0x16 ; 22 1f4: d1 e0 ldi r29, 0x01 ; 1 1f6: e0 e0 ldi r30, 0x00 ; 0 1f8: f0 e0 ldi r31, 0x00 ; 0 t->laps = 0; #endif for (a=0; a { t->ID = a; 202: ec 93 st X, r30 tasks[a] = t; 204: ee 0f add r30, r30 206: ff 1f adc r31, r31 208: ea 5e subi r30, 0xEA ; 234 20a: fe 4f sbci r31, 0xFE ; 254 20c: b1 83 std Z+1, r27 ; 0x01 20e: a0 83 st Z, r26 210: 05 c0 rjmp .+10 ; 0x21c break; 212: 31 96 adiw r30, 0x01 ; 1 214: 22 96 adiw r28, 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; 21c: 80 91 0a 01 lds r24, 0x010A 220: 8f bf out 0x3f, r24 ; 63 return; } 222: df 91 pop r29 224: cf 91 pop r28 226: 08 95 ret 00000228 : //* output: TRUE(ok)/NULL(error) * //**************************************************** #ifdef TASK_USE_ANHILATE uint8_t task_anhilate(Task *t) { 228: 0f 93 push r16 22a: 1f 93 push r17 22c: fc 01 movw r30, r24 sregsys=SREG; 22e: 8f b7 in r24, 0x3f ; 63 230: 80 93 0a 01 sts 0x010A, r24 cli(); 234: f8 94 cli #ifdef TASK_USE_SEMAPHORE //uint8_t *s = (uint8_t*) Semaphore; //uint8_t i; #endif uint8_t ID = t->ID; 236: 10 81 ld r17, Z if (ID > NUMBER || ID == 0) 238: 81 2f mov r24, r17 23a: 81 50 subi r24, 0x01 ; 1 23c: 80 31 cpi r24, 0x10 ; 16 23e: 28 f0 brcs .+10 ; 0x24a { SREG=sregsys; 240: 80 91 0a 01 lds r24, 0x010A 244: 8f bf out 0x3f, r24 ; 63 246: 80 e0 ldi r24, 0x00 ; 0 248: 6c c0 rjmp .+216 ; 0x322 return 0; } a=ID; //reset task values if (ID == currentTask) 24a: 61 2f mov r22, r17 24c: 70 e0 ldi r23, 0x00 ; 0 24e: 80 91 00 01 lds r24, 0x0100 252: 99 27 eor r25, r25 254: 87 fd sbrc r24, 7 256: 90 95 com r25 258: 68 17 cp r22, r24 25a: 79 07 cpc r23, r25 25c: 21 f4 brne .+8 ; 0x266 current = 0; //to avoid problems when deleting the current task 25e: 10 92 09 01 sts 0x0109, r1 262: 10 92 08 01 sts 0x0108, r1 tasks[a] = 0; //this deletes the task 266: fb 01 movw r30, r22 268: ee 0f add r30, r30 26a: ff 1f adc r31, r31 26c: ea 5e subi r30, 0xEA ; 234 26e: fe 4f sbci r31, 0xFE ; 254 270: 11 82 std Z+1, r1 ; 0x01 272: 10 82 st Z, r1 274: 50 e0 ldi r21, 0x00 ; 0 #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;aowner == ID) 276: 03 e0 ldi r16, 0x03 ; 3 278: 32 c0 rjmp .+100 ; 0x2de 27a: 50 9f mul r21, r16 27c: f0 01 movw r30, r0 27e: 11 24 eor r1, r1 280: e0 5f subi r30, 0xF0 ; 240 282: fe 4f sbci r31, 0xFE ; 254 284: 80 81 ld r24, Z 286: 81 17 cp r24, r17 288: 49 f5 brne .+82 ; 0x2dc { (blocks+a)->ptr=0; 28a: 12 82 std Z+2, r1 ; 0x02 28c: 11 82 std Z+1, r1 ; 0x01 (blocks+a)->owner=0; 28e: 10 82 st Z, r1 290: 45 2f mov r20, r21 292: 16 c0 rjmp .+44 ; 0x2c0 for (b=a;b<(currentBlocks-1);b++) blocks[b]=blocks[b+1]; 294: c9 01 movw r24, r18 296: 01 96 adiw r24, 0x01 ; 1 298: d9 01 movw r26, r18 29a: aa 0f add r26, r26 29c: bb 1f adc r27, r27 29e: a2 0f add r26, r18 2a0: b3 1f adc r27, r19 2a2: fc 01 movw r30, r24 2a4: ee 0f add r30, r30 2a6: ff 1f adc r31, r31 2a8: e8 0f add r30, r24 2aa: f9 1f adc r31, r25 2ac: a0 5f subi r26, 0xF0 ; 240 2ae: be 4f sbci r27, 0xFE ; 254 2b0: e0 5f subi r30, 0xF0 ; 240 2b2: fe 4f sbci r31, 0xFE ; 254 2b4: 83 e0 ldi r24, 0x03 ; 3 2b6: 01 90 ld r0, Z+ 2b8: 0d 92 st X+, r0 2ba: 81 50 subi r24, 0x01 ; 1 2bc: e1 f7 brne .-8 ; 0x2b6 { if ((blocks+a)->owner == ID) { (blocks+a)->ptr=0; (blocks+a)->owner=0; for (b=a;b<(currentBlocks-1);b++) 2be: 4f 5f subi r20, 0xFF ; 255 2c0: 24 2f mov r18, r20 2c2: 30 e0 ldi r19, 0x00 ; 0 2c4: 80 91 0b 01 lds r24, 0x010B 2c8: 90 e0 ldi r25, 0x00 ; 0 2ca: 01 97 sbiw r24, 0x01 ; 1 2cc: 28 17 cp r18, r24 2ce: 39 07 cpc r19, r25 2d0: 0c f3 brlt .-62 ; 0x294 blocks[b]=blocks[b+1]; currentBlocks--; 2d2: 80 91 0b 01 lds r24, 0x010B 2d6: 81 50 subi r24, 0x01 ; 1 2d8: 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) 2e6: 80 91 00 01 lds r24, 0x0100 2ea: 99 27 eor r25, r25 2ec: 87 fd sbrc r24, 7 2ee: 90 95 com r25 2f0: 68 17 cp r22, r24 2f2: 79 07 cpc r23, r25 2f4: 29 f0 breq .+10 ; 0x300 { //go back to parent task SREG=sregsys; 2f6: 80 91 0a 01 lds r24, 0x010A 2fa: 8f bf out 0x3f, r24 ; 63 2fc: 81 e0 ldi r24, 0x01 ; 1 2fe: 11 c0 rjmp .+34 ; 0x322 return TRUE; } else { //switch to next task without going back to the deleted task if it's the parent task TIMER_REG = _BV(CS00); 300: 81 e0 ldi r24, 0x01 ; 1 302: 85 bd out 0x25, r24 ; 37 TCNT0 = 0xFF; 304: 8f ef ldi r24, 0xFF ; 255 306: 86 bd out 0x26, r24 ; 38 currentTask = -1; 308: 80 93 00 01 sts 0x0100, r24 set_sleep_mode(SLEEP_MODE_IDLE); 30c: 83 b7 in r24, 0x33 ; 51 30e: 81 7f andi r24, 0xF1 ; 241 310: 83 bf out 0x33, r24 ; 51 sei(); 312: 78 94 sei sleep_mode(); 314: 83 b7 in r24, 0x33 ; 51 316: 81 60 ori r24, 0x01 ; 1 318: 83 bf out 0x33, r24 ; 51 31a: 88 95 sleep 31c: 83 b7 in r24, 0x33 ; 51 31e: 8e 7f andi r24, 0xFE ; 254 320: 83 bf out 0x33, r24 ; 51 } } 322: 1f 91 pop r17 324: 0f 91 pop r16 326: 08 95 ret 00000328 : //* output: none * //**************************************************** void task_switch() { cli(); 328: f8 94 cli set_sleep_mode(SLEEP_MODE_IDLE); 32a: 83 b7 in r24, 0x33 ; 51 32c: 81 7f andi r24, 0xF1 ; 241 32e: 83 bf out 0x33, r24 ; 51 TCNT0 = 0xf0; 330: 80 ef ldi r24, 0xF0 ; 240 332: 86 bd out 0x26, r24 ; 38 TIMER_REG = _BV(CS00); 334: 81 e0 ldi r24, 0x01 ; 1 336: 85 bd out 0x25, r24 ; 37 TIMER_ENABLE |= _BV(TOIE0); 338: ee e6 ldi r30, 0x6E ; 110 33a: f0 e0 ldi r31, 0x00 ; 0 33c: 80 81 ld r24, Z 33e: 81 60 ori r24, 0x01 ; 1 340: 80 83 st Z, r24 sei(); 342: 78 94 sei sleep_mode(); 344: 83 b7 in r24, 0x33 ; 51 346: 81 60 ori r24, 0x01 ; 1 348: 83 bf out 0x33, r24 ; 51 34a: 88 95 sleep 34c: 83 b7 in r24, 0x33 ; 51 34e: 8e 7f andi r24, 0xFE ; 254 350: 83 bf out 0x33, r24 ; 51 } 352: 08 95 ret 00000354 : //* description: set new priority for current Task * //* input: TaskPrio (low/medium/high) * //* output: new TaskPrio * //**************************************************** uint8_t taskNewPrio(TaskPrio prio) {return current->prio = prio;} 354: e0 91 08 01 lds r30, 0x0108 358: f0 91 09 01 lds r31, 0x0109 35c: 84 83 std Z+4, r24 ; 0x04 35e: 84 81 ldd r24, Z+4 ; 0x04 360: 08 95 ret 00000362 : { while (1) { wdt_reset(); set_sleep_mode(SLEEP_MODE_IDLE); TIMER_REG = _BV(CS00); 362: 21 e0 ldi r18, 0x01 ; 1 TCNT0 = 0xFF; 364: 9f ef ldi r25, 0xFF ; 255 void idle() { while (1) { wdt_reset(); 366: a8 95 wdr set_sleep_mode(SLEEP_MODE_IDLE); 368: 83 b7 in r24, 0x33 ; 51 36a: 81 7f andi r24, 0xF1 ; 241 36c: 83 bf out 0x33, r24 ; 51 TIMER_REG = _BV(CS00); 36e: 25 bd out 0x25, r18 ; 37 TCNT0 = 0xFF; 370: 96 bd out 0x26, r25 ; 38 sleep_mode(); 372: 83 b7 in r24, 0x33 ; 51 374: 81 60 ori r24, 0x01 ; 1 376: 83 bf out 0x33, r24 ; 51 378: 88 95 sleep 37a: 83 b7 in r24, 0x33 ; 51 37c: 8e 7f andi r24, 0xFE ; 254 37e: 83 bf out 0x33, r24 ; 51 380: f2 cf rjmp .-28 ; 0x366 00000382 : //* description: check if memory is available * //* input: no * //* output: number of free memory blocks * //**************************************************** uint8_t memory_get_free_blocks() {return MAXBLOCKS - currentBlocks;} 382: 90 91 0b 01 lds r25, 0x010B 386: 82 e0 ldi r24, 0x02 ; 2 388: 89 1b sub r24, r25 38a: 08 95 ret 0000038c : //* output: pointer to memory block or 0 (error) * //**************************************************** void* memory_allocate_block() { sregsys = SREG; 38c: 8f b7 in r24, 0x3f ; 63 38e: 80 93 0a 01 sts 0x010A, r24 cli(); 392: f8 94 cli if (currentBlocks >= MAXBLOCKS) 394: 80 91 0b 01 lds r24, 0x010B 398: 82 30 cpi r24, 0x02 ; 2 39a: 48 f5 brcc .+82 ; 0x3ee SREG = sregsys; return 0; } uint8_t a; char* ptr; mem_block_intern* block = (blocks+currentBlocks); 39c: 90 91 0b 01 lds r25, 0x010B 3a0: 83 e0 ldi r24, 0x03 ; 3 3a2: 98 9f mul r25, r24 3a4: f0 01 movw r30, r0 3a6: 11 24 eor r1, r1 3a8: e0 5f subi r30, 0xF0 ; 240 3aa: fe 4f sbci r31, 0xFE ; 254 //insert block //set a pointer to the memory block block->ptr = data+(currentBlocks*BLOCKSIZE); 3ac: 80 91 0b 01 lds r24, 0x010B 3b0: 90 e0 ldi r25, 0x00 ; 0 3b2: 82 5f subi r24, 0xF2 ; 242 3b4: 9e 4f sbci r25, 0xFE ; 254 3b6: 92 83 std Z+2, r25 ; 0x02 3b8: 81 83 std Z+1, r24 ; 0x01 ptr = (char*) block->ptr; 3ba: a1 81 ldd r26, Z+1 ; 0x01 3bc: b2 81 ldd r27, Z+2 ; 0x02 //leave if theres not enough memory if (block->ptr == 0 || (uint16_t) block->ptr > HEAPSTART) 3be: 81 81 ldd r24, Z+1 ; 0x01 3c0: 92 81 ldd r25, Z+2 ; 0x02 3c2: 89 2b or r24, r25 3c4: a1 f0 breq .+40 ; 0x3ee 3c6: 81 81 ldd r24, Z+1 ; 0x01 3c8: 92 81 ldd r25, Z+2 ; 0x02 3ca: 80 50 subi r24, 0x00 ; 0 3cc: 93 40 sbci r25, 0x03 ; 3 3ce: 78 f4 brcc .+30 ; 0x3ee SREG = sregsys; return 0; } //clear memory for (a=0;aowner = currentTask; 3d2: 80 91 00 01 lds r24, 0x0100 3d6: 80 83 st Z, r24 currentBlocks++; 3d8: 80 91 0b 01 lds r24, 0x010B 3dc: 8f 5f subi r24, 0xFF ; 255 3de: 80 93 0b 01 sts 0x010B, r24 SREG = sregsys; 3e2: 80 91 0a 01 lds r24, 0x010A 3e6: 8f bf out 0x3f, r24 ; 63 //return pointer to memory block return (void*) block->ptr; 3e8: 21 81 ldd r18, Z+1 ; 0x01 3ea: 32 81 ldd r19, Z+2 ; 0x02 3ec: 05 c0 rjmp .+10 ; 0x3f8 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; 3ee: 80 91 0a 01 lds r24, 0x010A 3f2: 8f bf out 0x3f, r24 ; 63 3f4: 20 e0 ldi r18, 0x00 ; 0 3f6: 30 e0 ldi r19, 0x00 ; 0 block->owner = currentTask; currentBlocks++; SREG = sregsys; //return pointer to memory block return (void*) block->ptr; } 3f8: c9 01 movw r24, r18 3fa: 08 95 ret 000003fc : //* input: pointer to allocated memory block * //* output: TRUE (ok) or ZERO (error) * //**************************************************** uint8_t memory_free_block(void* ptr) { 3fc: 9c 01 movw r18, r24 sregsys = SREG; 3fe: 8f b7 in r24, 0x3f ; 63 400: 80 93 0a 01 sts 0x010A, r24 cli(); 404: f8 94 cli 406: 40 e0 ldi r20, 0x00 ; 0 uint8_t a,b; //search for correct memory block for (a=0;aptr == ptr) 408: 53 e0 ldi r21, 0x03 ; 3 40a: 47 c0 rjmp .+142 ; 0x49a 40c: 45 9f mul r20, r21 40e: f0 01 movw r30, r0 410: 11 24 eor r1, r1 412: e0 5f subi r30, 0xF0 ; 240 414: fe 4f sbci r31, 0xFE ; 254 416: 81 81 ldd r24, Z+1 ; 0x01 418: 92 81 ldd r25, Z+2 ; 0x02 41a: 82 17 cp r24, r18 41c: 93 07 cpc r25, r19 41e: e1 f5 brne .+120 ; 0x498 { if ((blocks+a)->owner != currentTask) 420: 20 81 ld r18, Z 422: 80 91 00 01 lds r24, 0x0100 426: 30 e0 ldi r19, 0x00 ; 0 428: 99 27 eor r25, r25 42a: 87 fd sbrc r24, 7 42c: 90 95 com r25 42e: 28 17 cp r18, r24 430: 39 07 cpc r19, r25 432: 29 f0 breq .+10 ; 0x43e { SREG = sregsys; 434: 80 91 0a 01 lds r24, 0x010A 438: 8f bf out 0x3f, r24 ; 63 43a: 80 e0 ldi r24, 0x00 ; 0 43c: 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; 43e: 12 82 std Z+2, r1 ; 0x02 440: 11 82 std Z+1, r1 ; 0x01 (blocks+a)->owner=0; 442: 10 82 st Z, r1 444: 16 c0 rjmp .+44 ; 0x472 //re-organize memory blocks for (b=a;b<(currentBlocks-1);b++) blocks[b]=blocks[b+1]; 446: c9 01 movw r24, r18 448: 01 96 adiw r24, 0x01 ; 1 44a: d9 01 movw r26, r18 44c: aa 0f add r26, r26 44e: bb 1f adc r27, r27 450: a2 0f add r26, r18 452: b3 1f adc r27, r19 454: fc 01 movw r30, r24 456: ee 0f add r30, r30 458: ff 1f adc r31, r31 45a: e8 0f add r30, r24 45c: f9 1f adc r31, r25 45e: a0 5f subi r26, 0xF0 ; 240 460: be 4f sbci r27, 0xFE ; 254 462: e0 5f subi r30, 0xF0 ; 240 464: fe 4f sbci r31, 0xFE ; 254 466: 83 e0 ldi r24, 0x03 ; 3 468: 01 90 ld r0, Z+ 46a: 0d 92 st X+, r0 46c: 81 50 subi r24, 0x01 ; 1 46e: e1 f7 brne .-8 ; 0x468 //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++) 470: 4f 5f subi r20, 0xFF ; 255 472: 24 2f mov r18, r20 474: 30 e0 ldi r19, 0x00 ; 0 476: 80 91 0b 01 lds r24, 0x010B 47a: 90 e0 ldi r25, 0x00 ; 0 47c: 01 97 sbiw r24, 0x01 ; 1 47e: 28 17 cp r18, r24 480: 39 07 cpc r19, r25 482: 0c f3 brlt .-62 ; 0x446 blocks[b]=blocks[b+1]; currentBlocks--; 484: 80 91 0b 01 lds r24, 0x010B 488: 81 50 subi r24, 0x01 ; 1 48a: 80 93 0b 01 sts 0x010B, r24 SREG = sregsys; 48e: 80 91 0a 01 lds r24, 0x010A 492: 8f bf out 0x3f, r24 ; 63 494: 81 e0 ldi r24, 0x01 ; 1 496: 08 95 ret { sregsys = SREG; cli(); uint8_t a,b; //search for correct memory block for (a=0;a 4a2: b4 cf rjmp .-152 ; 0x40c currentBlocks--; SREG = sregsys; return TRUE; } } SREG = sregsys; 4a4: 80 91 0a 01 lds r24, 0x010A 4a8: 8f bf out 0x3f, r24 ; 63 4aa: 80 e0 ldi r24, 0x00 ; 0 return 0; } 4ac: 08 95 ret 000004ae : //* input: Queue *qp: Pointer to queue * //* output: free places in the queue * //**************************************************** uint8_t queue_exists(Queue *qp) { 4ae: fc 01 movw r30, r24 if (qp->queueDepth) 4b0: 81 81 ldd r24, Z+1 ; 0x01 4b2: 81 11 cpse r24, r1 4b4: 81 e0 ldi r24, 0x01 ; 1 return TRUE; return 0; } 4b6: 08 95 ret 000004b8 : //* input: Queue *qp: Pointer to queue * //* output: maximum number of messages in the queue * //**************************************************** uint8_t queue_get_maximum_size(Queue *qp) { 4b8: fc 01 movw r30, r24 return qp->queueDepth; 4ba: 81 81 ldd r24, Z+1 ; 0x01 } 4bc: 08 95 ret 000004be : //* input: Pointer to queue * //* output: free places in the queue * //**************************************************** uint8_t queue_get_free_size(Queue *qp) { 4be: fc 01 movw r30, r24 return qp->queueDepth - qp->number; 4c0: 81 81 ldd r24, Z+1 ; 0x01 4c2: 92 81 ldd r25, Z+2 ; 0x02 } 4c4: 89 1b sub r24, r25 4c6: 08 95 ret 000004c8 : //* input: Queue *qp: Pointer to queue * //* output: number of messages in the queue * //**************************************************** uint8_t queue_get_mumber_of_messages(Queue *qp) { 4c8: fc 01 movw r30, r24 return qp->number; 4ca: 82 81 ldd r24, Z+2 ; 0x02 } 4cc: 08 95 ret 000004ce : //* input: Queue *qp: Pointer to queue * //* output: TRUE (new message), ZERO (error) * //**************************************************** uint8_t queue_wait_for_message(Queue *qp) { 4ce: fc 01 movw r30, r24 //enable multitasking to avoid a deadrun wdt_enable(WDTO_2S); 4d0: 2f e0 ldi r18, 0x0F ; 15 4d2: 88 e1 ldi r24, 0x18 ; 24 4d4: 90 e0 ldi r25, 0x00 ; 0 4d6: 0f b6 in r0, 0x3f ; 63 4d8: f8 94 cli 4da: a8 95 wdr 4dc: 80 93 60 00 sts 0x0060, r24 4e0: 0f be out 0x3f, r0 ; 63 4e2: 20 93 60 00 sts 0x0060, r18 TIMER_ENABLE |= _BV(TOIE0); 4e6: 80 91 6e 00 lds r24, 0x006E 4ea: 81 60 ori r24, 0x01 ; 1 4ec: 80 93 6e 00 sts 0x006E, r24 sei(); 4f0: 78 94 sei if (qp->queueDepth == 0) 4f2: 81 81 ldd r24, Z+1 ; 0x01 4f4: 88 23 and r24, r24 4f6: 19 f4 brne .+6 ; 0x4fe 4f8: 08 95 ret return 0; while (qp->number == 0) TCNT0=0xFF; 4fa: 96 bd out 0x26, r25 ; 38 4fc: 01 c0 rjmp .+2 ; 0x500 <__stack+0x1> 4fe: 9f ef ldi r25, 0xFF ; 255 wdt_enable(WDTO_2S); TIMER_ENABLE |= _BV(TOIE0); sei(); if (qp->queueDepth == 0) return 0; while (qp->number == 0) 500: 82 81 ldd r24, Z+2 ; 0x02 502: 88 23 and r24, r24 504: d1 f3 breq .-12 ; 0x4fa 506: 81 e0 ldi r24, 0x01 ; 1 TCNT0=0xFF; return TRUE; } 508: 08 95 ret 0000050a : //* Works only with 1-byte-item Queues! * //* * //*********************************************************************** unsigned char queue_read_byte(Queue *qp, uint8_t position, uint8_t delete_message) { 50a: cf 93 push r28 50c: df 93 push r29 50e: ec 01 movw r28, r24 sregsys = SREG; 510: 8f b7 in r24, 0x3f ; 63 512: 80 93 0a 01 sts 0x010A, r24 cli(); 516: f8 94 cli uint8_t i; unsigned char tempmsg; if (qp->number == 0 || qp->number <= position || qp->item_size != 1) 518: 8a 81 ldd r24, Y+2 ; 0x02 51a: 88 23 and r24, r24 51c: 31 f0 breq .+12 ; 0x52a 51e: 8a 81 ldd r24, Y+2 ; 0x02 520: 68 17 cp r22, r24 522: 18 f4 brcc .+6 ; 0x52a 524: 88 81 ld r24, Y 526: 81 30 cpi r24, 0x01 ; 1 528: 21 f0 breq .+8 ; 0x532 { SREG = sregsys; 52a: 80 91 0a 01 lds r24, 0x010A 52e: 8f bf out 0x3f, r24 ; 63 530: 24 c0 rjmp .+72 ; 0x57a return; } //read message tempmsg = qp->message[position]; 532: ed 81 ldd r30, Y+5 ; 0x05 534: fe 81 ldd r31, Y+6 ; 0x06 536: e6 0f add r30, r22 538: f1 1d adc r31, r1 53a: 50 81 ld r21, Z if (delete_message) 53c: 44 23 and r20, r20 53e: 71 f4 brne .+28 ; 0x55c 540: 18 c0 rjmp .+48 ; 0x572 { //re-organize message queue (FIFO) for (i=position;i<(qp->number)-1;i++) qp->message[i] = qp->message[i+1]; 542: ed 81 ldd r30, Y+5 ; 0x05 544: fe 81 ldd r31, Y+6 ; 0x06 546: e2 0f add r30, r18 548: f3 1f adc r31, r19 54a: ad 81 ldd r26, Y+5 ; 0x05 54c: be 81 ldd r27, Y+6 ; 0x06 54e: 2f 5f subi r18, 0xFF ; 255 550: 3f 4f sbci r19, 0xFF ; 255 552: a2 0f add r26, r18 554: b3 1f adc r27, r19 556: 8c 91 ld r24, X 558: 80 83 st Z, r24 //read message tempmsg = qp->message[position]; if (delete_message) { //re-organize message queue (FIFO) for (i=position;i<(qp->number)-1;i++) 55a: 6f 5f subi r22, 0xFF ; 255 55c: 8a 81 ldd r24, Y+2 ; 0x02 55e: 26 2f mov r18, r22 560: 30 e0 ldi r19, 0x00 ; 0 562: 90 e0 ldi r25, 0x00 ; 0 564: 01 97 sbiw r24, 0x01 ; 1 566: 28 17 cp r18, r24 568: 39 07 cpc r19, r25 56a: 5c f3 brlt .-42 ; 0x542 qp->message[i] = qp->message[i+1]; qp->number--; 56c: 8a 81 ldd r24, Y+2 ; 0x02 56e: 81 50 subi r24, 0x01 ; 1 570: 8a 83 std Y+2, r24 ; 0x02 } SREG = sregsys; 572: 80 91 0a 01 lds r24, 0x010A 576: 8f bf out 0x3f, r24 ; 63 578: 85 2f mov r24, r21 return tempmsg; } 57a: df 91 pop r29 57c: cf 91 pop r28 57e: 08 95 ret 00000580 : } } //this is the display task for the hours void display_hours() { 580: cf 93 push r28 582: df 93 push r29 //* output: free places in the queue * //**************************************************** uint8_t queue_exists(Queue *qp) { if (qp->queueDepth) 584: 80 91 c8 01 lds r24, 0x01C8 588: 88 23 and r24, r24 58a: 21 f0 breq .+8 ; 0x594 //* description: check if memory is available * //* input: no * //* output: number of free memory blocks * //**************************************************** uint8_t memory_get_free_blocks() {return MAXBLOCKS - currentBlocks;} 58c: 80 91 0b 01 lds r24, 0x010B if (!(queue_exists(&hours_queue)) || !(memory_get_free_blocks())) 590: 82 30 cpi r24, 0x02 ; 2 592: 21 f4 brne .+8 ; 0x59c task_anhilate(&display_hours_task); 594: 8e ec ldi r24, 0xCE ; 206 596: 91 e0 ldi r25, 0x01 ; 1 598: 0e 94 14 01 call 0x228 ; 0x228 unsigned char* hrs_ptr = memory_allocate_block(); 59c: 0e 94 c6 01 call 0x38c ; 0x38c 5a0: ec 01 movw r28, r24 while (1) { //Wait for new hour message queue_wait_for_message(&hours_queue); 5a2: 87 ec ldi r24, 0xC7 ; 199 5a4: 91 e0 ldi r25, 0x01 ; 1 5a6: 0e 94 67 02 call 0x4ce ; 0x4ce //set PORTC to new hour value *hrs_ptr = queue_read_byte(&hours_queue,0,1); 5aa: 87 ec ldi r24, 0xC7 ; 199 5ac: 91 e0 ldi r25, 0x01 ; 1 5ae: 60 e0 ldi r22, 0x00 ; 0 5b0: 41 e0 ldi r20, 0x01 ; 1 5b2: 0e 94 85 02 call 0x50a ; 0x50a 5b6: 88 83 st Y, r24 PORTC = *hrs_ptr; 5b8: 88 b9 out 0x08, r24 ; 8 5ba: f3 cf rjmp .-26 ; 0x5a2 000005bc : //+++Task functions+++ //this is the display task for the minutes void display_minutes() { 5bc: cf 93 push r28 5be: df 93 push r29 5c0: 80 91 14 02 lds r24, 0x0214 5c4: 88 23 and r24, r24 5c6: 21 f0 breq .+8 ; 0x5d0 5c8: 80 91 0b 01 lds r24, 0x010B if (!(queue_exists(&minutes_queue)) || !(memory_get_free_blocks())) 5cc: 82 30 cpi r24, 0x02 ; 2 5ce: 21 f4 brne .+8 ; 0x5d8 task_anhilate(&display_minutes_task); 5d0: 82 e8 ldi r24, 0x82 ; 130 5d2: 91 e0 ldi r25, 0x01 ; 1 5d4: 0e 94 14 01 call 0x228 ; 0x228 unsigned char* min_ptr = memory_allocate_block(); 5d8: 0e 94 c6 01 call 0x38c ; 0x38c 5dc: ec 01 movw r28, r24 while (1) { //Wait for new minute message queue_wait_for_message(&minutes_queue); 5de: 83 e1 ldi r24, 0x13 ; 19 5e0: 92 e0 ldi r25, 0x02 ; 2 5e2: 0e 94 67 02 call 0x4ce ; 0x4ce //set PORTD to new minute value *min_ptr = queue_read_byte(&minutes_queue,0,1); 5e6: 83 e1 ldi r24, 0x13 ; 19 5e8: 92 e0 ldi r25, 0x02 ; 2 5ea: 60 e0 ldi r22, 0x00 ; 0 5ec: 41 e0 ldi r20, 0x01 ; 1 5ee: 0e 94 85 02 call 0x50a ; 0x50a 5f2: 88 83 st Y, r24 PORTD = *min_ptr; 5f4: 8b b9 out 0x0b, r24 ; 11 5f6: f3 cf rjmp .-26 ; 0x5de 000005f8 : //* 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) { 5f8: ef 92 push r14 5fa: ff 92 push r15 5fc: 0f 93 push r16 5fe: 1f 93 push r17 600: cf 93 push r28 602: df 93 push r29 604: ec 01 movw r28, r24 606: 8b 01 movw r16, r22 608: 94 2f mov r25, r20 60a: e2 2e mov r14, r18 sregsys = SREG; 60c: 8f b7 in r24, 0x3f ; 63 60e: 80 93 0a 01 sts 0x010A, r24 cli(); 612: f8 94 cli uint8_t i,j; position = position * qp->item_size; // get correct message for the given entry. 614: 48 81 ld r20, Y if (qp->number == 0 || qp->number <= position || targetpointer == 0) 616: 8a 81 ldd r24, Y+2 ; 0x02 618: 88 23 and r24, r24 61a: 69 f0 breq .+26 ; 0x636 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. 61c: 94 9f mul r25, r20 61e: 40 2d mov r20, r0 620: 11 24 eor r1, r1 if (qp->number == 0 || qp->number <= position || targetpointer == 0) 622: 8a 81 ldd r24, Y+2 ; 0x02 624: 48 17 cp r20, r24 626: 38 f4 brcc .+14 ; 0x636 628: 61 15 cp r22, r1 62a: 71 05 cpc r23, r1 62c: 21 f0 breq .+8 ; 0x636 62e: f4 2e mov r15, r20 { SREG = sregsys; return 0; } //read messages for (i=position;i<(position+qp->item_size);i++) 630: 64 2f mov r22, r20 632: 70 e0 ldi r23, 0x00 ; 0 634: 36 c0 rjmp .+108 ; 0x6a2 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; 636: 80 91 0a 01 lds r24, 0x010A 63a: 8f bf out 0x3f, r24 ; 63 63c: 80 e0 ldi r24, 0x00 ; 0 63e: 3e c0 rjmp .+124 ; 0x6bc 640: d9 01 movw r26, r18 642: a6 1b sub r26, r22 644: b7 0b sbc r27, r23 return 0; } //read messages for (i=position;i<(position+qp->item_size);i++) { if (delete_message) 646: ee 20 and r14, r14 648: 19 f1 breq .+70 ; 0x690 { *(targetpointer+(i-position)) = qp->message[position]; 64a: ed 81 ldd r30, Y+5 ; 0x05 64c: fe 81 ldd r31, Y+6 ; 0x06 64e: e6 0f add r30, r22 650: f7 1f adc r31, r23 652: 80 81 ld r24, Z 654: a0 0f add r26, r16 656: b1 1f adc r27, r17 658: 8c 93 st X, r24 65a: 54 2f mov r21, r20 65c: 0d c0 rjmp .+26 ; 0x678 //re-organize message queue (FIFO) for (j=position;j<(qp->number)-1;j++) qp->message[j] = qp->message[j+1]; 65e: ed 81 ldd r30, Y+5 ; 0x05 660: fe 81 ldd r31, Y+6 ; 0x06 662: e2 0f add r30, r18 664: f3 1f adc r31, r19 666: ad 81 ldd r26, Y+5 ; 0x05 668: be 81 ldd r27, Y+6 ; 0x06 66a: 2f 5f subi r18, 0xFF ; 255 66c: 3f 4f sbci r19, 0xFF ; 255 66e: a2 0f add r26, r18 670: b3 1f adc r27, r19 672: 8c 91 ld r24, X 674: 80 83 st Z, r24 { if (delete_message) { *(targetpointer+(i-position)) = qp->message[position]; //re-organize message queue (FIFO) for (j=position;j<(qp->number)-1;j++) 676: 5f 5f subi r21, 0xFF ; 255 678: 8a 81 ldd r24, Y+2 ; 0x02 67a: 25 2f mov r18, r21 67c: 30 e0 ldi r19, 0x00 ; 0 67e: 90 e0 ldi r25, 0x00 ; 0 680: 01 97 sbiw r24, 0x01 ; 1 682: 28 17 cp r18, r24 684: 39 07 cpc r19, r25 686: 5c f3 brlt .-42 ; 0x65e qp->message[j] = qp->message[j+1]; qp->number--; 688: 8a 81 ldd r24, Y+2 ; 0x02 68a: 81 50 subi r24, 0x01 ; 1 68c: 8a 83 std Y+2, r24 ; 0x02 68e: 08 c0 rjmp .+16 ; 0x6a0 } else *(targetpointer+(i-position)) = qp->message[i]; 690: ed 81 ldd r30, Y+5 ; 0x05 692: fe 81 ldd r31, Y+6 ; 0x06 694: e2 0f add r30, r18 696: f3 1f adc r31, r19 698: 80 81 ld r24, Z 69a: a0 0f add r26, r16 69c: b1 1f adc r27, r17 69e: 8c 93 st X, r24 { SREG = sregsys; return 0; } //read messages for (i=position;i<(position+qp->item_size);i++) 6a0: f3 94 inc r15 6a2: 2f 2d mov r18, r15 6a4: 30 e0 ldi r19, 0x00 ; 0 6a6: 88 81 ld r24, Y 6a8: fb 01 movw r30, r22 6aa: e8 0f add r30, r24 6ac: f1 1d adc r31, r1 6ae: 2e 17 cp r18, r30 6b0: 3f 07 cpc r19, r31 6b2: 34 f2 brlt .-116 ; 0x640 qp->number--; } else *(targetpointer+(i-position)) = qp->message[i]; } SREG = sregsys; 6b4: 80 91 0a 01 lds r24, 0x010A 6b8: 8f bf out 0x3f, r24 ; 63 6ba: 81 e0 ldi r24, 0x01 ; 1 return TRUE; } 6bc: df 91 pop r29 6be: cf 91 pop r28 6c0: 1f 91 pop r17 6c2: 0f 91 pop r16 6c4: ff 90 pop r15 6c6: ef 90 pop r14 6c8: 08 95 ret 000006ca : //* input: Queue *qp: Pointer to queue * //* output: Pointer * //*********************************************** void* queue_read_pointer (Queue *qp) { 6ca: fc 01 movw r30, r24 return (void*) qp->ptr; 6cc: 23 81 ldd r18, Z+3 ; 0x03 6ce: 34 81 ldd r19, Z+4 ; 0x04 } 6d0: c9 01 movw r24, r18 6d2: 08 95 ret 000006d4 : //* Works only with 1-byte-item Queues! * //* * //**************************************************** uint8_t queue_write_byte (Queue *qp, unsigned char message) { 6d4: dc 01 movw r26, r24 sregsys = SREG; 6d6: 8f b7 in r24, 0x3f ; 63 6d8: 80 93 0a 01 sts 0x010A, r24 cli(); 6dc: f8 94 cli uint8_t mlen = qp->number; 6de: 12 96 adiw r26, 0x02 ; 2 6e0: 2c 91 ld r18, X 6e2: 12 97 sbiw r26, 0x02 ; 2 if (mlen > (qp->queueDepth - 1) || qp->item_size != 1) 6e4: 11 96 adiw r26, 0x01 ; 1 6e6: 8c 91 ld r24, X 6e8: 11 97 sbiw r26, 0x01 ; 1 6ea: 90 e0 ldi r25, 0x00 ; 0 6ec: 30 e0 ldi r19, 0x00 ; 0 6ee: 28 17 cp r18, r24 6f0: 39 07 cpc r19, r25 6f2: 1c f4 brge .+6 ; 0x6fa 6f4: 8c 91 ld r24, X 6f6: 81 30 cpi r24, 0x01 ; 1 6f8: 29 f0 breq .+10 ; 0x704 { SREG = sregsys; 6fa: 80 91 0a 01 lds r24, 0x010A 6fe: 8f bf out 0x3f, r24 ; 63 700: 80 e0 ldi r24, 0x00 ; 0 702: 08 95 ret return 0; } //insert message qp->message[mlen]=message; 704: 15 96 adiw r26, 0x05 ; 5 706: ed 91 ld r30, X+ 708: fc 91 ld r31, X 70a: 16 97 sbiw r26, 0x06 ; 6 70c: e2 0f add r30, r18 70e: f3 1f adc r31, r19 710: 60 83 st Z, r22 qp->number++; 712: 12 96 adiw r26, 0x02 ; 2 714: 8c 91 ld r24, X 716: 12 97 sbiw r26, 0x02 ; 2 718: 8f 5f subi r24, 0xFF ; 255 71a: 12 96 adiw r26, 0x02 ; 2 71c: 8c 93 st X, r24 SREG = sregsys; 71e: 80 91 0a 01 lds r24, 0x010A 722: 8f bf out 0x3f, r24 ; 63 724: 81 e0 ldi r24, 0x01 ; 1 return TRUE; } 726: 08 95 ret 00000728 : //ISR for Pin Change Interrupts - Buttons void button_press_12() { // button1 is pressed if (! (PINB & _BV(PB1))) 728: 19 99 sbic 0x03, 1 ; 3 72a: 0b c0 rjmp .+22 ; 0x742 { //disable interrupt fpr debounce PCMSK0 &= ~_BV(PCINT1); 72c: 80 91 6b 00 lds r24, 0x006B 730: 8d 7f andi r24, 0xFD ; 253 732: 80 93 6b 00 sts 0x006B, r24 //Button 1 is pressed so send a "1" to time_calc_task queue_write_byte(&time_calc_queue, 1); 736: 86 e3 ldi r24, 0x36 ; 54 738: 91 e0 ldi r25, 0x01 ; 1 73a: 61 e0 ldi r22, 0x01 ; 1 73c: 0e 94 6a 03 call 0x6d4 ; 0x6d4 740: 08 95 ret return; } // button2 is pressed if (! (PINB & _BV(PB2))) 742: 1a 99 sbic 0x03, 2 ; 3 744: 0a c0 rjmp .+20 ; 0x75a { //disable interrupt fpr debounce PCMSK0 &= ~_BV(PCINT2); 746: 80 91 6b 00 lds r24, 0x006B 74a: 8b 7f andi r24, 0xFB ; 251 74c: 80 93 6b 00 sts 0x006B, r24 //Button 2 is pressed so send a "2" to time_calc_task queue_write_byte(&time_calc_queue, 2); 750: 86 e3 ldi r24, 0x36 ; 54 752: 91 e0 ldi r25, 0x01 ; 1 754: 62 e0 ldi r22, 0x02 ; 2 756: 0e 94 6a 03 call 0x6d4 ; 0x6d4 75a: 08 95 ret 0000075c <__vector_3>: { tick_time(); } SIGNAL(SIG_PIN_CHANGE0) { 75c: 1f 92 push r1 75e: 0f 92 push r0 760: 0f b6 in r0, 0x3f ; 63 762: 0f 92 push r0 764: 11 24 eor r1, r1 766: 2f 93 push r18 768: 3f 93 push r19 76a: 4f 93 push r20 76c: 5f 93 push r21 76e: 6f 93 push r22 770: 7f 93 push r23 772: 8f 93 push r24 774: 9f 93 push r25 776: af 93 push r26 778: bf 93 push r27 77a: ef 93 push r30 77c: ff 93 push r31 button_press_12(); 77e: 0e 94 94 03 call 0x728 ; 0x728 } 782: ff 91 pop r31 784: ef 91 pop r30 786: bf 91 pop r27 788: af 91 pop r26 78a: 9f 91 pop r25 78c: 8f 91 pop r24 78e: 7f 91 pop r23 790: 6f 91 pop r22 792: 5f 91 pop r21 794: 4f 91 pop r20 796: 3f 91 pop r19 798: 2f 91 pop r18 79a: 0f 90 pop r0 79c: 0f be out 0x3f, r0 ; 63 79e: 0f 90 pop r0 7a0: 1f 90 pop r1 7a2: 18 95 reti 000007a4 : //ISR for Timer2 - Clock timer void tick_time() { static uint8_t zaehler; zaehler++; 7a4: 80 91 0c 01 lds r24, 0x010C 7a8: 8f 5f subi r24, 0xFF ; 255 7aa: 80 93 0c 01 sts 0x010C, r24 if (zaehler == 122) //Interrupt is called @ 8 Mhz / (256*256) = 122 times per second 7ae: 8a 37 cpi r24, 0x7A ; 122 7b0: 41 f4 brne .+16 ; 0x7c2 { //we have a new second so send a message to time_calc task; zaehler = 0; 7b2: 10 92 0c 01 sts 0x010C, r1 queue_write_byte(&time_calc_queue, 128); //anything but 1 or 2 7b6: 86 e3 ldi r24, 0x36 ; 54 7b8: 91 e0 ldi r25, 0x01 ; 1 7ba: 60 e8 ldi r22, 0x80 ; 128 7bc: 0e 94 6a 03 call 0x6d4 ; 0x6d4 7c0: 08 95 ret } //debounce for buttons (enable button interrupts again after 0,3 seconds; else if (!(zaehler % 30)) 7c2: 6e e1 ldi r22, 0x1E ; 30 7c4: 0e 94 67 05 call 0xace ; 0xace <__udivmodqi4> 7c8: 99 23 and r25, r25 7ca: 51 f4 brne .+20 ; 0x7e0 { PCMSK0 |= _BV(PCINT1); 7cc: 80 91 6b 00 lds r24, 0x006B 7d0: 82 60 ori r24, 0x02 ; 2 7d2: 80 93 6b 00 sts 0x006B, r24 PCMSK0 |= _BV(PCINT2); 7d6: 80 91 6b 00 lds r24, 0x006B 7da: 84 60 ori r24, 0x04 ; 4 7dc: 80 93 6b 00 sts 0x006B, r24 7e0: 08 95 ret 000007e2 <__vector_9>: void button_press_12(void); //Interrupt Handler SIGNAL (TIMER2_OVF_vect) { 7e2: 1f 92 push r1 7e4: 0f 92 push r0 7e6: 0f b6 in r0, 0x3f ; 63 7e8: 0f 92 push r0 7ea: 11 24 eor r1, r1 7ec: 2f 93 push r18 7ee: 3f 93 push r19 7f0: 4f 93 push r20 7f2: 5f 93 push r21 7f4: 6f 93 push r22 7f6: 7f 93 push r23 7f8: 8f 93 push r24 7fa: 9f 93 push r25 7fc: af 93 push r26 7fe: bf 93 push r27 800: ef 93 push r30 802: ff 93 push r31 tick_time(); 804: 0e 94 d2 03 call 0x7a4 ; 0x7a4 } 808: ff 91 pop r31 80a: ef 91 pop r30 80c: bf 91 pop r27 80e: af 91 pop r26 810: 9f 91 pop r25 812: 8f 91 pop r24 814: 7f 91 pop r23 816: 6f 91 pop r22 818: 5f 91 pop r21 81a: 4f 91 pop r20 81c: 3f 91 pop r19 81e: 2f 91 pop r18 820: 0f 90 pop r0 822: 0f be out 0x3f, r0 ; 63 824: 0f 90 pop r0 826: 1f 90 pop r1 828: 18 95 reti 0000082a : } } //this calculates the time void time_calc() { 82a: df 92 push r13 82c: ef 92 push r14 82e: ff 92 push r15 830: 0f 93 push r16 832: 1f 93 push r17 834: cf 93 push r28 836: df 93 push r29 m = 0; } // else it must be a new second else { TASK_ENTER_CRITICAL; 838: 78 e1 ldi r23, 0x18 ; 24 83a: d7 2e mov r13, r23 h++; if (h == 24) h = 0; } } TASK_LEAVE_CRITICAL; 83c: c8 e1 ldi r28, 0x18 ; 24 83e: d0 e0 ldi r29, 0x00 ; 0 840: 6f e0 ldi r22, 0x0F ; 15 842: e6 2e mov r14, r22 uint8_t h,m,s; unsigned char calc_msg; while (1) { //wait for message. A message appears every second or when a button is pressed. queue_wait_for_message(&time_calc_queue); 844: 86 e3 ldi r24, 0x36 ; 54 846: 91 e0 ldi r25, 0x01 ; 1 848: 0e 94 67 02 call 0x4ce ; 0x4ce calc_msg = queue_read_byte(&time_calc_queue,0,1); 84c: 86 e3 ldi r24, 0x36 ; 54 84e: 91 e0 ldi r25, 0x01 ; 1 850: 60 e0 ldi r22, 0x00 ; 0 852: 41 e0 ldi r20, 0x01 ; 1 854: 0e 94 85 02 call 0x50a ; 0x50a // if button 1 is pressed increase hours if (calc_msg == 1) 858: 81 30 cpi r24, 0x01 ; 1 85a: 31 f4 brne .+12 ; 0x868 { if (h < 23) 85c: 07 31 cpi r16, 0x17 ; 23 85e: 10 f0 brcs .+4 ; 0x864 860: 00 e0 ldi r16, 0x00 ; 0 862: 2e c0 rjmp .+92 ; 0x8c0 h++; 864: 0f 5f subi r16, 0xFF ; 255 866: 2c c0 rjmp .+88 ; 0x8c0 else h = 0; } // if button 2 is pressed increase minutes else if (calc_msg == 2) 868: 82 30 cpi r24, 0x02 ; 2 86a: 31 f4 brne .+12 ; 0x878 { if (m < 59) 86c: 1b 33 cpi r17, 0x3B ; 59 86e: 10 f0 brcs .+4 ; 0x874 870: 10 e0 ldi r17, 0x00 ; 0 872: 26 c0 rjmp .+76 ; 0x8c0 m++; 874: 1f 5f subi r17, 0xFF ; 255 876: 24 c0 rjmp .+72 ; 0x8c0 m = 0; } // else it must be a new second else { TASK_ENTER_CRITICAL; 878: 8f b7 in r24, 0x3f ; 63 87a: 80 93 0d 01 sts 0x010D, r24 87e: 0f b6 in r0, 0x3f ; 63 880: f8 94 cli 882: d0 92 60 00 sts 0x0060, r13 886: 10 92 60 00 sts 0x0060, r1 88a: 0f be out 0x3f, r0 ; 63 88c: f8 94 cli s++; 88e: f3 94 inc r15 if (s == 60) 890: 8c e3 ldi r24, 0x3C ; 60 892: f8 16 cp r15, r24 894: 49 f4 brne .+18 ; 0x8a8 { s = 0; m++; 896: 1f 5f subi r17, 0xFF ; 255 if (m == 60) 898: 1c 33 cpi r17, 0x3C ; 60 89a: 29 f4 brne .+10 ; 0x8a6 { m = 0; h++; 89c: 0f 5f subi r16, 0xFF ; 255 if (h == 24) 89e: 08 31 cpi r16, 0x18 ; 24 8a0: 09 f4 brne .+2 ; 0x8a4 8a2: 00 e0 ldi r16, 0x00 ; 0 8a4: 10 e0 ldi r17, 0x00 ; 0 8a6: ff 24 eor r15, r15 h = 0; } } TASK_LEAVE_CRITICAL; 8a8: 78 94 sei 8aa: 0f b6 in r0, 0x3f ; 63 8ac: f8 94 cli 8ae: a8 95 wdr 8b0: c0 93 60 00 sts 0x0060, r28 8b4: 0f be out 0x3f, r0 ; 63 8b6: e0 92 60 00 sts 0x0060, r14 8ba: 80 91 0d 01 lds r24, 0x010D 8be: 8f bf out 0x3f, r24 ; 63 } //send time to display tasks; queue_write_byte(&minutes_queue,m); 8c0: 83 e1 ldi r24, 0x13 ; 19 8c2: 92 e0 ldi r25, 0x02 ; 2 8c4: 61 2f mov r22, r17 8c6: 0e 94 6a 03 call 0x6d4 ; 0x6d4 queue_write_byte(&hours_queue,h); 8ca: 87 ec ldi r24, 0xC7 ; 199 8cc: 91 e0 ldi r25, 0x01 ; 1 8ce: 60 2f mov r22, r16 8d0: 0e 94 6a 03 call 0x6d4 ; 0x6d4 8d4: b7 cf rjmp .-146 ; 0x844 000008d6 : //* * //* output: TRUE(ok), ZERO (error) * //******************************************************************* uint8_t queue_write_item (Queue *qp, void* startpointer) { 8d6: cf 93 push r28 8d8: df 93 push r29 8da: dc 01 movw r26, r24 8dc: eb 01 movw r28, r22 sregsys = SREG; 8de: 8f b7 in r24, 0x3f ; 63 8e0: 80 93 0a 01 sts 0x010A, r24 cli(); 8e4: f8 94 cli uint8_t mlen = qp->number,i=0; 8e6: 12 96 adiw r26, 0x02 ; 2 8e8: 2c 91 ld r18, X 8ea: 12 97 sbiw r26, 0x02 ; 2 uint8_t length = qp->item_size; 8ec: 6c 91 ld r22, X if (mlen + length > qp->queueDepth) 8ee: 11 96 adiw r26, 0x01 ; 1 8f0: 8c 91 ld r24, X 8f2: 11 97 sbiw r26, 0x01 ; 1 8f4: 42 2f mov r20, r18 8f6: 50 e0 ldi r21, 0x00 ; 0 8f8: 9a 01 movw r18, r20 8fa: 26 0f add r18, r22 8fc: 31 1d adc r19, r1 8fe: 90 e0 ldi r25, 0x00 ; 0 900: 82 17 cp r24, r18 902: 93 07 cpc r25, r19 904: 1c f0 brlt .+6 ; 0x90c 906: 9a 01 movw r18, r20 908: 90 e0 ldi r25, 0x00 ; 0 90a: 17 c0 rjmp .+46 ; 0x93a { SREG = sregsys; 90c: 80 91 0a 01 lds r24, 0x010A 910: 8f bf out 0x3f, r24 ; 63 912: 80 e0 ldi r24, 0x00 ; 0 914: 18 c0 rjmp .+48 ; 0x946 return 0; } //insert message as 1-byte chunks for (i=0;imessage[mlen+i]=*((unsigned char*)startpointer++); 916: 15 96 adiw r26, 0x05 ; 5 918: ed 91 ld r30, X+ 91a: fc 91 ld r31, X 91c: 16 97 sbiw r26, 0x06 ; 6 91e: e2 0f add r30, r18 920: f3 1f adc r31, r19 922: 89 91 ld r24, Y+ 924: 80 83 st Z, r24 qp->number++; 926: 12 96 adiw r26, 0x02 ; 2 928: 8c 91 ld r24, X 92a: 12 97 sbiw r26, 0x02 ; 2 92c: 8f 5f subi r24, 0xFF ; 255 92e: 12 96 adiw r26, 0x02 ; 2 930: 8c 93 st X, r24 932: 12 97 sbiw r26, 0x02 ; 2 { 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; 93e: 80 91 0a 01 lds r24, 0x010A 942: 8f bf out 0x3f, r24 ; 63 944: 81 e0 ldi r24, 0x01 ; 1 return TRUE; } 946: df 91 pop r29 948: cf 91 pop r28 94a: 08 95 ret 0000094c : //* void* Pointer: pointer to begin of word * //* output: TRUE(ok), ZERO (error) * //******************************************************* uint8_t queue_write_pointer (Queue *qp, void* pointer) { 94c: fc 01 movw r30, r24 sregsys = SREG; 94e: 8f b7 in r24, 0x3f ; 63 950: 80 93 0a 01 sts 0x010A, r24 cli(); 954: f8 94 cli if (pointer == 0) 956: 61 15 cp r22, r1 958: 71 05 cpc r23, r1 95a: 29 f4 brne .+10 ; 0x966 { SREG = sregsys; 95c: 80 91 0a 01 lds r24, 0x010A 960: 8f bf out 0x3f, r24 ; 63 962: 80 e0 ldi r24, 0x00 ; 0 964: 08 95 ret return 0; } //insert pointer qp->ptr = pointer; 966: 74 83 std Z+4, r23 ; 0x04 968: 63 83 std Z+3, r22 ; 0x03 SREG = sregsys; 96a: 80 91 0a 01 lds r24, 0x010A 96e: 8f bf out 0x3f, r24 ; 63 970: 81 e0 ldi r24, 0x01 ; 1 return TRUE; } 972: 08 95 ret 00000974 : //* input: Queue *qp: Pointer to queue * //* output: TRUE(ok), ZERO(error) * //**************************************************** uint8_t queue_anhilate(Queue *qp) { 974: cf 93 push r28 976: df 93 push r29 978: ec 01 movw r28, r24 sregsys = SREG; 97a: 8f b7 in r24, 0x3f ; 63 97c: 80 93 0a 01 sts 0x010A, r24 cli(); 980: f8 94 cli if (qp->message == 0) 982: 8d 81 ldd r24, Y+5 ; 0x05 984: 9e 81 ldd r25, Y+6 ; 0x06 986: 89 2b or r24, r25 988: 29 f4 brne .+10 ; 0x994 { SREG = sregsys; 98a: 80 91 0a 01 lds r24, 0x010A 98e: 8f bf out 0x3f, r24 ; 63 990: 80 e0 ldi r24, 0x00 ; 0 992: 0c c0 rjmp .+24 ; 0x9ac return 0; } //free memory and reset other values free ((void*) qp->message); 994: 8d 81 ldd r24, Y+5 ; 0x05 996: 9e 81 ldd r25, Y+6 ; 0x06 998: 0e 94 20 06 call 0xc40 ; 0xc40 qp->message = 0; 99c: 1e 82 std Y+6, r1 ; 0x06 99e: 1d 82 std Y+5, r1 ; 0x05 qp->number = 0; 9a0: 1a 82 std Y+2, r1 ; 0x02 qp->queueDepth = 0; 9a2: 19 82 std Y+1, r1 ; 0x01 SREG = sregsys; 9a4: 80 91 0a 01 lds r24, 0x010A 9a8: 8f bf out 0x3f, r24 ; 63 9aa: 81 e0 ldi r24, 0x01 ; 1 return TRUE; } 9ac: df 91 pop r29 9ae: cf 91 pop r28 9b0: 08 95 ret 000009b2 : //* 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) { 9b2: 0f 93 push r16 9b4: 1f 93 push r17 9b6: cf 93 push r28 9b8: df 93 push r29 9ba: ec 01 movw r28, r24 9bc: 16 2f mov r17, r22 9be: 04 2f mov r16, r20 sregsys = SREG; 9c0: 8f b7 in r24, 0x3f ; 63 9c2: 80 93 0a 01 sts 0x010A, r24 cli(); 9c6: f8 94 cli if (MessageQueueDepth == 0 || item_size == 0 || MessageQueueDepth > MAXQUEUEDEPTH) 9c8: 66 23 and r22, r22 9ca: b9 f0 breq .+46 ; 0x9fa 9cc: 44 23 and r20, r20 9ce: a9 f0 breq .+42 ; 0x9fa 9d0: 63 30 cpi r22, 0x03 ; 3 9d2: 98 f4 brcc .+38 ; 0x9fa { SREG = sregsys; return 0; } //allocate memory for queue dynamically qp->message = (unsigned char*) malloc (MessageQueueDepth*item_size); 9d4: 46 9f mul r20, r22 9d6: c0 01 movw r24, r0 9d8: 11 24 eor r1, r1 9da: 0e 94 73 05 call 0xae6 ; 0xae6 9de: 9e 83 std Y+6, r25 ; 0x06 9e0: 8d 83 std Y+5, r24 ; 0x05 if (qp->message == 0 || (uint16_t) qp->message > SP) 9e2: 8d 81 ldd r24, Y+5 ; 0x05 9e4: 9e 81 ldd r25, Y+6 ; 0x06 9e6: 89 2b or r24, r25 9e8: 39 f0 breq .+14 ; 0x9f8 9ea: 2d 81 ldd r18, Y+5 ; 0x05 9ec: 3e 81 ldd r19, Y+6 ; 0x06 9ee: 8d b7 in r24, 0x3d ; 61 9f0: 9e b7 in r25, 0x3e ; 62 9f2: 82 17 cp r24, r18 9f4: 93 07 cpc r25, r19 9f6: 30 f4 brcc .+12 ; 0xa04 { qp->queueDepth = 0; 9f8: 19 82 std Y+1, r1 ; 0x01 SREG = sregsys; 9fa: 80 91 0a 01 lds r24, 0x010A 9fe: 8f bf out 0x3f, r24 ; 63 a00: 80 e0 ldi r24, 0x00 ; 0 a02: 0b c0 rjmp .+22 ; 0xa1a return 0; } qp->queueDepth = MessageQueueDepth*item_size; a04: 01 9f mul r16, r17 a06: 80 2d mov r24, r0 a08: 11 24 eor r1, r1 a0a: 89 83 std Y+1, r24 ; 0x01 qp->item_size = item_size; a0c: 08 83 st Y, r16 qp->ptr = 0; a0e: 1c 82 std Y+4, r1 ; 0x04 a10: 1b 82 std Y+3, r1 ; 0x03 SREG = sregsys; a12: 80 91 0a 01 lds r24, 0x010A a16: 8f bf out 0x3f, r24 ; 63 a18: 81 e0 ldi r24, 0x01 ; 1 return TRUE; } a1a: df 91 pop r29 a1c: cf 91 pop r28 a1e: 1f 91 pop r17 a20: 0f 91 pop r16 a22: 08 95 ret 00000a24
: #ifdef TASK_USE_SEMAPHORE #include "system/semaphore.c" #endif int main() { a24: df 93 push r29 a26: cf 93 push r28 a28: cd b7 in r28, 0x3d ; 61 a2a: de b7 in r29, 0x3e ; 62 a2c: c5 54 subi r28, 0x45 ; 69 a2e: d0 40 sbci r29, 0x00 ; 0 a30: 0f b6 in r0, 0x3f ; 63 a32: f8 94 cli a34: de bf out 0x3e, r29 ; 62 a36: 0f be out 0x3f, r0 ; 63 a38: cd bf out 0x3d, r28 ; 61 static void kernel() { //Create an idle-task Task idletask; task_create(&idletask,idle,TaskPriorityLow); a3a: ce 01 movw r24, r28 a3c: 01 96 adiw r24, 0x01 ; 1 a3e: 61 eb ldi r22, 0xB1 ; 177 a40: 71 e0 ldi r23, 0x01 ; 1 a42: 4f ef ldi r20, 0xFF ; 255 a44: 0e 94 d7 00 call 0x1ae ; 0x1ae //enable watchdog wdt_enable(WDTO_2S); a48: 2f e0 ldi r18, 0x0F ; 15 a4a: 88 e1 ldi r24, 0x18 ; 24 a4c: 90 e0 ldi r25, 0x00 ; 0 a4e: 0f b6 in r0, 0x3f ; 63 a50: f8 94 cli a52: a8 95 wdr a54: 80 93 60 00 sts 0x0060, r24 a58: 0f be out 0x3f, r0 ; 63 a5a: 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); a5e: 82 e8 ldi r24, 0x82 ; 130 a60: 91 e0 ldi r25, 0x01 ; 1 a62: 6e ed ldi r22, 0xDE ; 222 a64: 72 e0 ldi r23, 0x02 ; 2 a66: 4f ef ldi r20, 0xFF ; 255 a68: 0e 94 d7 00 call 0x1ae ; 0x1ae task_create(&display_hours_task, display_hours, TaskPriorityLow); a6c: 8e ec ldi r24, 0xCE ; 206 a6e: 91 e0 ldi r25, 0x01 ; 1 a70: 60 ec ldi r22, 0xC0 ; 192 a72: 72 e0 ldi r23, 0x02 ; 2 a74: 4f ef ldi r20, 0xFF ; 255 a76: 0e 94 d7 00 call 0x1ae ; 0x1ae task_create(&time_calc_task, time_calc, TaskPriorityLow); a7a: 8d e3 ldi r24, 0x3D ; 61 a7c: 91 e0 ldi r25, 0x01 ; 1 a7e: 65 e1 ldi r22, 0x15 ; 21 a80: 74 e0 ldi r23, 0x04 ; 4 a82: 4f ef ldi r20, 0xFF ; 255 a84: 0e 94 d7 00 call 0x1ae ; 0x1ae //init Queues queue_init(&minutes_queue,1,1); a88: 83 e1 ldi r24, 0x13 ; 19 a8a: 92 e0 ldi r25, 0x02 ; 2 a8c: 61 e0 ldi r22, 0x01 ; 1 a8e: 41 e0 ldi r20, 0x01 ; 1 a90: 0e 94 d9 04 call 0x9b2 ; 0x9b2 queue_init(&time_calc_queue,1,1); a94: 86 e3 ldi r24, 0x36 ; 54 a96: 91 e0 ldi r25, 0x01 ; 1 a98: 61 e0 ldi r22, 0x01 ; 1 a9a: 41 e0 ldi r20, 0x01 ; 1 a9c: 0e 94 d9 04 call 0x9b2 ; 0x9b2 queue_init(&hours_queue,2,1); aa0: 87 ec ldi r24, 0xC7 ; 199 aa2: 91 e0 ldi r25, 0x01 ; 1 aa4: 62 e0 ldi r22, 0x02 ; 2 aa6: 41 e0 ldi r20, 0x01 ; 1 aa8: 0e 94 d9 04 call 0x9b2 ; 0x9b2 //set DDRB and DDRC as output DDRC=0xFF; aac: 8f ef ldi r24, 0xFF ; 255 aae: 87 b9 out 0x07, r24 ; 7 DDRD=0xFF; ab0: 8a b9 out 0x0a, r24 ; 10 //setup timer2 TCCR2B = _BV(CS22) | _BV(CS21); // div by 256 ab2: 86 e0 ldi r24, 0x06 ; 6 ab4: 80 93 b1 00 sts 0x00B1, r24 // We will overflow 122 times a second, and call an interrupt // enable interrupt TIMSK2 = _BV(TOIE2); ab8: 91 e0 ldi r25, 0x01 ; 1 aba: 90 93 70 00 sts 0x0070, r25 //Enable pullup resistor on PIN PB1 and PB2 PORTB = _BV(PB1) | _BV(PB2); abe: 85 b9 out 0x05, r24 ; 5 //These are the interrupts for the buttons PCICR = _BV(PCIE0); ac0: 90 93 68 00 sts 0x0068, r25 PCMSK0 = _BV(PCINT1) | _BV(PCINT2); ac4: 80 93 6b 00 sts 0x006B, r24 //init user specific stuff init_user_environment(); //start scheduler task_switch(); ac8: 0e 94 94 01 call 0x328 ; 0x328 acc: ff cf rjmp .-2 ; 0xacc 00000ace <__udivmodqi4>: ace: 99 1b sub r25, r25 ad0: 79 e0 ldi r23, 0x09 ; 9 ad2: 04 c0 rjmp .+8 ; 0xadc <__udivmodqi4_ep> 00000ad4 <__udivmodqi4_loop>: ad4: 99 1f adc r25, r25 ad6: 96 17 cp r25, r22 ad8: 08 f0 brcs .+2 ; 0xadc <__udivmodqi4_ep> ada: 96 1b sub r25, r22 00000adc <__udivmodqi4_ep>: adc: 88 1f adc r24, r24 ade: 7a 95 dec r23 ae0: c9 f7 brne .-14 ; 0xad4 <__udivmodqi4_loop> ae2: 80 95 com r24 ae4: 08 95 ret 00000ae6 : ae6: cf 93 push r28 ae8: df 93 push r29 aea: bc 01 movw r22, r24 aec: 82 30 cpi r24, 0x02 ; 2 aee: 91 05 cpc r25, r1 af0: 10 f4 brcc .+4 ; 0xaf6 af2: 62 e0 ldi r22, 0x02 ; 2 af4: 70 e0 ldi r23, 0x00 ; 0 af6: a0 91 1c 02 lds r26, 0x021C afa: b0 91 1d 02 lds r27, 0x021D afe: ed 01 movw r28, r26 b00: e0 e0 ldi r30, 0x00 ; 0 b02: f0 e0 ldi r31, 0x00 ; 0 b04: 40 e0 ldi r20, 0x00 ; 0 b06: 50 e0 ldi r21, 0x00 ; 0 b08: 21 c0 rjmp .+66 ; 0xb4c b0a: 88 81 ld r24, Y b0c: 99 81 ldd r25, Y+1 ; 0x01 b0e: 86 17 cp r24, r22 b10: 97 07 cpc r25, r23 b12: 69 f4 brne .+26 ; 0xb2e b14: 8a 81 ldd r24, Y+2 ; 0x02 b16: 9b 81 ldd r25, Y+3 ; 0x03 b18: 30 97 sbiw r30, 0x00 ; 0 b1a: 19 f0 breq .+6 ; 0xb22 b1c: 93 83 std Z+3, r25 ; 0x03 b1e: 82 83 std Z+2, r24 ; 0x02 b20: 04 c0 rjmp .+8 ; 0xb2a b22: 90 93 1d 02 sts 0x021D, r25 b26: 80 93 1c 02 sts 0x021C, r24 b2a: fe 01 movw r30, r28 b2c: 34 c0 rjmp .+104 ; 0xb96 b2e: 68 17 cp r22, r24 b30: 79 07 cpc r23, r25 b32: 38 f4 brcc .+14 ; 0xb42 b34: 41 15 cp r20, r1 b36: 51 05 cpc r21, r1 b38: 19 f0 breq .+6 ; 0xb40 b3a: 84 17 cp r24, r20 b3c: 95 07 cpc r25, r21 b3e: 08 f4 brcc .+2 ; 0xb42 b40: ac 01 movw r20, r24 b42: fe 01 movw r30, r28 b44: 8a 81 ldd r24, Y+2 ; 0x02 b46: 9b 81 ldd r25, Y+3 ; 0x03 b48: 9c 01 movw r18, r24 b4a: e9 01 movw r28, r18 b4c: 20 97 sbiw r28, 0x00 ; 0 b4e: e9 f6 brne .-70 ; 0xb0a b50: 41 15 cp r20, r1 b52: 51 05 cpc r21, r1 b54: a9 f1 breq .+106 ; 0xbc0 b56: ca 01 movw r24, r20 b58: 86 1b sub r24, r22 b5a: 97 0b sbc r25, r23 b5c: 04 97 sbiw r24, 0x04 ; 4 b5e: 08 f4 brcc .+2 ; 0xb62 b60: ba 01 movw r22, r20 b62: e0 e0 ldi r30, 0x00 ; 0 b64: f0 e0 ldi r31, 0x00 ; 0 b66: 2a c0 rjmp .+84 ; 0xbbc b68: 8d 91 ld r24, X+ b6a: 9c 91 ld r25, X b6c: 11 97 sbiw r26, 0x01 ; 1 b6e: 84 17 cp r24, r20 b70: 95 07 cpc r25, r21 b72: f9 f4 brne .+62 ; 0xbb2 b74: 64 17 cp r22, r20 b76: 75 07 cpc r23, r21 b78: 81 f4 brne .+32 ; 0xb9a b7a: 12 96 adiw r26, 0x02 ; 2 b7c: 8d 91 ld r24, X+ b7e: 9c 91 ld r25, X b80: 13 97 sbiw r26, 0x03 ; 3 b82: 30 97 sbiw r30, 0x00 ; 0 b84: 19 f0 breq .+6 ; 0xb8c b86: 93 83 std Z+3, r25 ; 0x03 b88: 82 83 std Z+2, r24 ; 0x02 b8a: 04 c0 rjmp .+8 ; 0xb94 b8c: 90 93 1d 02 sts 0x021D, r25 b90: 80 93 1c 02 sts 0x021C, r24 b94: fd 01 movw r30, r26 b96: 32 96 adiw r30, 0x02 ; 2 b98: 4f c0 rjmp .+158 ; 0xc38 b9a: ca 01 movw r24, r20 b9c: 86 1b sub r24, r22 b9e: 97 0b sbc r25, r23 ba0: fd 01 movw r30, r26 ba2: e8 0f add r30, r24 ba4: f9 1f adc r31, r25 ba6: 61 93 st Z+, r22 ba8: 71 93 st Z+, r23 baa: 02 97 sbiw r24, 0x02 ; 2 bac: 8d 93 st X+, r24 bae: 9c 93 st X, r25 bb0: 43 c0 rjmp .+134 ; 0xc38 bb2: fd 01 movw r30, r26 bb4: 82 81 ldd r24, Z+2 ; 0x02 bb6: 93 81 ldd r25, Z+3 ; 0x03 bb8: 9c 01 movw r18, r24 bba: d9 01 movw r26, r18 bbc: 10 97 sbiw r26, 0x00 ; 0 bbe: a1 f6 brne .-88 ; 0xb68 bc0: 80 91 1a 02 lds r24, 0x021A bc4: 90 91 1b 02 lds r25, 0x021B bc8: 89 2b or r24, r25 bca: 41 f4 brne .+16 ; 0xbdc bcc: 80 91 03 01 lds r24, 0x0103 bd0: 90 91 04 01 lds r25, 0x0104 bd4: 90 93 1b 02 sts 0x021B, r25 bd8: 80 93 1a 02 sts 0x021A, r24 bdc: 40 91 05 01 lds r20, 0x0105 be0: 50 91 06 01 lds r21, 0x0106 be4: 41 15 cp r20, r1 be6: 51 05 cpc r21, r1 be8: 41 f4 brne .+16 ; 0xbfa bea: 4d b7 in r20, 0x3d ; 61 bec: 5e b7 in r21, 0x3e ; 62 bee: 80 91 01 01 lds r24, 0x0101 bf2: 90 91 02 01 lds r25, 0x0102 bf6: 48 1b sub r20, r24 bf8: 59 0b sbc r21, r25 bfa: 20 91 1a 02 lds r18, 0x021A bfe: 30 91 1b 02 lds r19, 0x021B c02: 24 17 cp r18, r20 c04: 35 07 cpc r19, r21 c06: b0 f4 brcc .+44 ; 0xc34 c08: ca 01 movw r24, r20 c0a: 82 1b sub r24, r18 c0c: 93 0b sbc r25, r19 c0e: 86 17 cp r24, r22 c10: 97 07 cpc r25, r23 c12: 80 f0 brcs .+32 ; 0xc34 c14: ab 01 movw r20, r22 c16: 4e 5f subi r20, 0xFE ; 254 c18: 5f 4f sbci r21, 0xFF ; 255 c1a: 84 17 cp r24, r20 c1c: 95 07 cpc r25, r21 c1e: 50 f0 brcs .+20 ; 0xc34 c20: 42 0f add r20, r18 c22: 53 1f adc r21, r19 c24: 50 93 1b 02 sts 0x021B, r21 c28: 40 93 1a 02 sts 0x021A, r20 c2c: f9 01 movw r30, r18 c2e: 61 93 st Z+, r22 c30: 71 93 st Z+, r23 c32: 02 c0 rjmp .+4 ; 0xc38 c34: e0 e0 ldi r30, 0x00 ; 0 c36: f0 e0 ldi r31, 0x00 ; 0 c38: cf 01 movw r24, r30 c3a: df 91 pop r29 c3c: cf 91 pop r28 c3e: 08 95 ret 00000c40 : c40: cf 93 push r28 c42: df 93 push r29 c44: 00 97 sbiw r24, 0x00 ; 0 c46: 09 f4 brne .+2 ; 0xc4a c48: 50 c0 rjmp .+160 ; 0xcea c4a: ec 01 movw r28, r24 c4c: 22 97 sbiw r28, 0x02 ; 2 c4e: 1b 82 std Y+3, r1 ; 0x03 c50: 1a 82 std Y+2, r1 ; 0x02 c52: a0 91 1c 02 lds r26, 0x021C c56: b0 91 1d 02 lds r27, 0x021D c5a: 10 97 sbiw r26, 0x00 ; 0 c5c: 09 f1 breq .+66 ; 0xca0 c5e: 40 e0 ldi r20, 0x00 ; 0 c60: 50 e0 ldi r21, 0x00 ; 0 c62: ac 17 cp r26, r28 c64: bd 07 cpc r27, r29 c66: 08 f1 brcs .+66 ; 0xcaa c68: bb 83 std Y+3, r27 ; 0x03 c6a: aa 83 std Y+2, r26 ; 0x02 c6c: fe 01 movw r30, r28 c6e: 21 91 ld r18, Z+ c70: 31 91 ld r19, Z+ c72: e2 0f add r30, r18 c74: f3 1f adc r31, r19 c76: ae 17 cp r26, r30 c78: bf 07 cpc r27, r31 c7a: 79 f4 brne .+30 ; 0xc9a c7c: 8d 91 ld r24, X+ c7e: 9c 91 ld r25, X c80: 11 97 sbiw r26, 0x01 ; 1 c82: 28 0f add r18, r24 c84: 39 1f adc r19, r25 c86: 2e 5f subi r18, 0xFE ; 254 c88: 3f 4f sbci r19, 0xFF ; 255 c8a: 39 83 std Y+1, r19 ; 0x01 c8c: 28 83 st Y, r18 c8e: 12 96 adiw r26, 0x02 ; 2 c90: 8d 91 ld r24, X+ c92: 9c 91 ld r25, X c94: 13 97 sbiw r26, 0x03 ; 3 c96: 9b 83 std Y+3, r25 ; 0x03 c98: 8a 83 std Y+2, r24 ; 0x02 c9a: 41 15 cp r20, r1 c9c: 51 05 cpc r21, r1 c9e: 71 f4 brne .+28 ; 0xcbc ca0: d0 93 1d 02 sts 0x021D, r29 ca4: c0 93 1c 02 sts 0x021C, r28 ca8: 20 c0 rjmp .+64 ; 0xcea caa: 12 96 adiw r26, 0x02 ; 2 cac: 8d 91 ld r24, X+ cae: 9c 91 ld r25, X cb0: 13 97 sbiw r26, 0x03 ; 3 cb2: ad 01 movw r20, r26 cb4: 00 97 sbiw r24, 0x00 ; 0 cb6: 11 f0 breq .+4 ; 0xcbc cb8: dc 01 movw r26, r24 cba: d3 cf rjmp .-90 ; 0xc62 cbc: fa 01 movw r30, r20 cbe: d3 83 std Z+3, r29 ; 0x03 cc0: c2 83 std Z+2, r28 ; 0x02 cc2: 21 91 ld r18, Z+ cc4: 31 91 ld r19, Z+ cc6: e2 0f add r30, r18 cc8: f3 1f adc r31, r19 cca: ce 17 cp r28, r30 ccc: df 07 cpc r29, r31 cce: 69 f4 brne .+26 ; 0xcea cd0: 88 81 ld r24, Y cd2: 99 81 ldd r25, Y+1 ; 0x01 cd4: 28 0f add r18, r24 cd6: 39 1f adc r19, r25 cd8: 2e 5f subi r18, 0xFE ; 254 cda: 3f 4f sbci r19, 0xFF ; 255 cdc: fa 01 movw r30, r20 cde: 31 83 std Z+1, r19 ; 0x01 ce0: 20 83 st Z, r18 ce2: 8a 81 ldd r24, Y+2 ; 0x02 ce4: 9b 81 ldd r25, Y+3 ; 0x03 ce6: 93 83 std Z+3, r25 ; 0x03 ce8: 82 83 std Z+2, r24 ; 0x02 cea: df 91 pop r29 cec: cf 91 pop r28 cee: 08 95 ret 00000cf0 <_exit>: cf0: f8 94 cli 00000cf2 <__stop_program>: cf2: ff cf rjmp .-2 ; 0xcf2 <__stop_program>