nano_os.elf: file format elf32-avr Sections: Idx Name Size VMA LMA File off Algn 0 .data 00000008 00800100 00000d3e 00000dd2 2**0 CONTENTS, ALLOC, LOAD, DATA 1 .text 00000d3e 00000000 00000000 00000094 2**1 CONTENTS, ALLOC, LOAD, READONLY, CODE 2 .bss 00000116 00800108 00800108 00000dda 2**0 ALLOC 3 .stab 000006b4 00000000 00000000 00000ddc 2**2 CONTENTS, READONLY, DEBUGGING 4 .stabstr 00000082 00000000 00000000 00001490 2**0 CONTENTS, READONLY, DEBUGGING 5 .debug_aranges 00000048 00000000 00000000 00001512 2**0 CONTENTS, READONLY, DEBUGGING 6 .debug_pubnames 0000036a 00000000 00000000 0000155a 2**0 CONTENTS, READONLY, DEBUGGING 7 .debug_info 00000c01 00000000 00000000 000018c4 2**0 CONTENTS, READONLY, DEBUGGING 8 .debug_abbrev 0000041d 00000000 00000000 000024c5 2**0 CONTENTS, READONLY, DEBUGGING 9 .debug_line 00000dba 00000000 00000000 000028e2 2**0 CONTENTS, READONLY, DEBUGGING 10 .debug_frame 00000230 00000000 00000000 0000369c 2**2 CONTENTS, READONLY, DEBUGGING 11 .debug_str 0000053a 00000000 00000000 000038cc 2**0 CONTENTS, READONLY, DEBUGGING 12 .debug_loc 00000863 00000000 00000000 00003e06 2**0 CONTENTS, READONLY, DEBUGGING 13 .debug_ranges 00000020 00000000 00000000 00004669 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 d3 03 jmp 0x7a6 ; 0x7a6 <__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 16 04 jmp 0x82c ; 0x82c <__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 d8 00 jmp 0x1b0 ; 0x1b0 <__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: ee e3 ldi r30, 0x3E ; 62 7c: fd e0 ldi r31, 0x0D ; 13 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 37 05 call 0xa6e ; 0xa6e
9e: 0c 94 9d 06 jmp 0xd3a ; 0xd3a <_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 <__vector_16>: #endif //+++++++++++++++++++++Signal-Handler++++++++++++++++++ SIGNAL (SIG_OVERFLOW0) { 1b0: 1f 92 push r1 1b2: 0f 92 push r0 1b4: 0f b6 in r0, 0x3f ; 63 1b6: 0f 92 push r0 1b8: 11 24 eor r1, r1 1ba: 2f 93 push r18 1bc: 3f 93 push r19 1be: 4f 93 push r20 1c0: 5f 93 push r21 1c2: 6f 93 push r22 1c4: 7f 93 push r23 1c6: 8f 93 push r24 1c8: 9f 93 push r25 1ca: af 93 push r26 1cc: bf 93 push r27 1ce: ef 93 push r30 1d0: ff 93 push r31 scheduler(); 1d2: 0e 94 53 00 call 0xa6 ; 0xa6 } 1d6: ff 91 pop r31 1d8: ef 91 pop r30 1da: bf 91 pop r27 1dc: af 91 pop r26 1de: 9f 91 pop r25 1e0: 8f 91 pop r24 1e2: 7f 91 pop r23 1e4: 6f 91 pop r22 1e6: 5f 91 pop r21 1e8: 4f 91 pop r20 1ea: 3f 91 pop r19 1ec: 2f 91 pop r18 1ee: 0f 90 pop r0 1f0: 0f be out 0x3f, r0 ; 63 1f2: 0f 90 pop r0 1f4: 1f 90 pop r1 1f6: 18 95 reti 000001f8 : //* Prio: Priority * //* output: none * //**************************************************** void task_create(Task *t, TaskFunction f, TaskPrio prio) { 1f8: cf 93 push r28 1fa: df 93 push r29 1fc: dc 01 movw r26, r24 sregsys = SREG; 1fe: 8f b7 in r24, 0x3f ; 63 200: 80 93 0a 01 sts 0x010A, r24 cli(); 204: f8 94 cli signed char a; unsigned char *s = (unsigned char *)(t->stack + sizeof(t->stack) - 3); 206: fd 01 movw r30, r26 208: ee 5b subi r30, 0xBE ; 190 20a: ff 4f sbci r31, 0xFF ; 255 20c: 8f e1 ldi r24, 0x1F ; 31 for (a=31; a>=0; a--) *s-- = 0; 20e: 10 82 st Z, r1 210: 31 97 sbiw r30, 0x01 ; 1 212: 81 50 subi r24, 0x01 ; 1 214: e0 f7 brcc .-8 ; 0x20e //init kontext: sreg = 0, SP = Pointer to t->stack (which contains the stack section and the PC) t->sreg = 0; 216: 11 96 adiw r26, 0x01 ; 1 218: 1c 92 st X, r1 21a: 11 97 sbiw r26, 0x01 ; 1 t->sp = (unsigned char *)(t->stack + sizeof(t->stack) - 3); 21c: cd 01 movw r24, r26 21e: 8e 5b subi r24, 0xBE ; 190 220: 9f 4f sbci r25, 0xFF ; 255 222: 13 96 adiw r26, 0x03 ; 3 224: 9c 93 st X, r25 226: 8e 93 st -X, r24 228: 12 97 sbiw r26, 0x02 ; 2 t->prio = prio; 22a: 14 96 adiw r26, 0x04 ; 4 22c: 4c 93 st X, r20 22e: 14 97 sbiw r26, 0x04 ; 4 t->stack[sizeof(t->stack)-2] = ((unsigned int)f)>>8; 230: ad 5b subi r26, 0xBD ; 189 232: bf 4f sbci r27, 0xFF ; 255 234: 7d 93 st X+, r23 t->stack[sizeof(t->stack)-1] = ((unsigned int)f)&0xff; 236: 6c 93 st X, r22 238: a4 54 subi r26, 0x44 ; 68 23a: b0 40 sbci r27, 0x00 ; 0 23c: c6 e1 ldi r28, 0x16 ; 22 23e: d1 e0 ldi r29, 0x01 ; 1 240: e0 e0 ldi r30, 0x00 ; 0 242: f0 e0 ldi r31, 0x00 ; 0 t->laps = 0; #endif for (a=0; a { t->ID = a; 24c: ec 93 st X, r30 tasks[a] = t; 24e: ee 0f add r30, r30 250: ff 1f adc r31, r31 252: ea 5e subi r30, 0xEA ; 234 254: fe 4f sbci r31, 0xFE ; 254 256: b1 83 std Z+1, r27 ; 0x01 258: a0 83 st Z, r26 25a: 05 c0 rjmp .+10 ; 0x266 break; 25c: 31 96 adiw r30, 0x01 ; 1 25e: 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; 266: 80 91 0a 01 lds r24, 0x010A 26a: 8f bf out 0x3f, r24 ; 63 return; } 26c: df 91 pop r29 26e: cf 91 pop r28 270: 08 95 ret 00000272 : //* output: TRUE(ok)/NULL(error) * //**************************************************** #ifdef TASK_USE_ANHILATE uint8_t task_anhilate(Task *t) { 272: 0f 93 push r16 274: 1f 93 push r17 276: fc 01 movw r30, r24 sregsys=SREG; 278: 8f b7 in r24, 0x3f ; 63 27a: 80 93 0a 01 sts 0x010A, r24 cli(); 27e: f8 94 cli #ifdef TASK_USE_SEMAPHORE //uint8_t *s = (uint8_t*) Semaphore; //uint8_t i; #endif uint8_t ID = t->ID; 280: 10 81 ld r17, Z if (ID > NUMBER || ID == 0) 282: 81 2f mov r24, r17 284: 81 50 subi r24, 0x01 ; 1 286: 80 31 cpi r24, 0x10 ; 16 288: 28 f0 brcs .+10 ; 0x294 { SREG=sregsys; 28a: 80 91 0a 01 lds r24, 0x010A 28e: 8f bf out 0x3f, r24 ; 63 290: 80 e0 ldi r24, 0x00 ; 0 292: 6c c0 rjmp .+216 ; 0x36c return 0; } a=ID; //reset task values if (ID == currentTask) 294: 61 2f mov r22, r17 296: 70 e0 ldi r23, 0x00 ; 0 298: 80 91 00 01 lds r24, 0x0100 29c: 99 27 eor r25, r25 29e: 87 fd sbrc r24, 7 2a0: 90 95 com r25 2a2: 68 17 cp r22, r24 2a4: 79 07 cpc r23, r25 2a6: 21 f4 brne .+8 ; 0x2b0 current = 0; //to avoid problems when deleting the current task 2a8: 10 92 09 01 sts 0x0109, r1 2ac: 10 92 08 01 sts 0x0108, r1 tasks[a] = 0; //this deletes the task 2b0: fb 01 movw r30, r22 2b2: ee 0f add r30, r30 2b4: ff 1f adc r31, r31 2b6: ea 5e subi r30, 0xEA ; 234 2b8: fe 4f sbci r31, 0xFE ; 254 2ba: 11 82 std Z+1, r1 ; 0x01 2bc: 10 82 st Z, r1 2be: 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) 2c0: 03 e0 ldi r16, 0x03 ; 3 2c2: 32 c0 rjmp .+100 ; 0x328 2c4: 50 9f mul r21, r16 2c6: f0 01 movw r30, r0 2c8: 11 24 eor r1, r1 2ca: e0 5f subi r30, 0xF0 ; 240 2cc: fe 4f sbci r31, 0xFE ; 254 2ce: 80 81 ld r24, Z 2d0: 81 17 cp r24, r17 2d2: 49 f5 brne .+82 ; 0x326 { (blocks+a)->ptr=0; 2d4: 12 82 std Z+2, r1 ; 0x02 2d6: 11 82 std Z+1, r1 ; 0x01 (blocks+a)->owner=0; 2d8: 10 82 st Z, r1 2da: 45 2f mov r20, r21 2dc: 16 c0 rjmp .+44 ; 0x30a for (b=a;b<(currentBlocks-1);b++) blocks[b]=blocks[b+1]; 2de: c9 01 movw r24, r18 2e0: 01 96 adiw r24, 0x01 ; 1 2e2: d9 01 movw r26, r18 2e4: aa 0f add r26, r26 2e6: bb 1f adc r27, r27 2e8: a2 0f add r26, r18 2ea: b3 1f adc r27, r19 2ec: fc 01 movw r30, r24 2ee: ee 0f add r30, r30 2f0: ff 1f adc r31, r31 2f2: e8 0f add r30, r24 2f4: f9 1f adc r31, r25 2f6: a0 5f subi r26, 0xF0 ; 240 2f8: be 4f sbci r27, 0xFE ; 254 2fa: e0 5f subi r30, 0xF0 ; 240 2fc: fe 4f sbci r31, 0xFE ; 254 2fe: 83 e0 ldi r24, 0x03 ; 3 300: 01 90 ld r0, Z+ 302: 0d 92 st X+, r0 304: 81 50 subi r24, 0x01 ; 1 306: e1 f7 brne .-8 ; 0x300 { if ((blocks+a)->owner == ID) { (blocks+a)->ptr=0; (blocks+a)->owner=0; for (b=a;b<(currentBlocks-1);b++) 308: 4f 5f subi r20, 0xFF ; 255 30a: 24 2f mov r18, r20 30c: 30 e0 ldi r19, 0x00 ; 0 30e: 80 91 0b 01 lds r24, 0x010B 312: 90 e0 ldi r25, 0x00 ; 0 314: 01 97 sbiw r24, 0x01 ; 1 316: 28 17 cp r18, r24 318: 39 07 cpc r19, r25 31a: 0c f3 brlt .-62 ; 0x2de blocks[b]=blocks[b+1]; currentBlocks--; 31c: 80 91 0b 01 lds r24, 0x010B 320: 81 50 subi r24, 0x01 ; 1 322: 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) 330: 80 91 00 01 lds r24, 0x0100 334: 99 27 eor r25, r25 336: 87 fd sbrc r24, 7 338: 90 95 com r25 33a: 68 17 cp r22, r24 33c: 79 07 cpc r23, r25 33e: 29 f0 breq .+10 ; 0x34a { //go back to parent task SREG=sregsys; 340: 80 91 0a 01 lds r24, 0x010A 344: 8f bf out 0x3f, r24 ; 63 346: 81 e0 ldi r24, 0x01 ; 1 348: 11 c0 rjmp .+34 ; 0x36c return TRUE; } else { //switch to next task without going back to the deleted task if it's the parent task TIMER_REG = _BV(CS00); 34a: 81 e0 ldi r24, 0x01 ; 1 34c: 85 bd out 0x25, r24 ; 37 TCNT0 = 0xFF; 34e: 8f ef ldi r24, 0xFF ; 255 350: 86 bd out 0x26, r24 ; 38 currentTask = -1; 352: 80 93 00 01 sts 0x0100, r24 set_sleep_mode(SLEEP_MODE_IDLE); 356: 83 b7 in r24, 0x33 ; 51 358: 81 7f andi r24, 0xF1 ; 241 35a: 83 bf out 0x33, r24 ; 51 sei(); 35c: 78 94 sei sleep_mode(); 35e: 83 b7 in r24, 0x33 ; 51 360: 81 60 ori r24, 0x01 ; 1 362: 83 bf out 0x33, r24 ; 51 364: 88 95 sleep 366: 83 b7 in r24, 0x33 ; 51 368: 8e 7f andi r24, 0xFE ; 254 36a: 83 bf out 0x33, r24 ; 51 } } 36c: 1f 91 pop r17 36e: 0f 91 pop r16 370: 08 95 ret 00000372 : //* output: none * //**************************************************** void task_switch() { cli(); 372: f8 94 cli set_sleep_mode(SLEEP_MODE_IDLE); 374: 83 b7 in r24, 0x33 ; 51 376: 81 7f andi r24, 0xF1 ; 241 378: 83 bf out 0x33, r24 ; 51 TCNT0 = 0xf0; 37a: 80 ef ldi r24, 0xF0 ; 240 37c: 86 bd out 0x26, r24 ; 38 TIMER_REG = _BV(CS00); 37e: 81 e0 ldi r24, 0x01 ; 1 380: 85 bd out 0x25, r24 ; 37 TIMER_ENABLE |= _BV(TOIE0); 382: ee e6 ldi r30, 0x6E ; 110 384: f0 e0 ldi r31, 0x00 ; 0 386: 80 81 ld r24, Z 388: 81 60 ori r24, 0x01 ; 1 38a: 80 83 st Z, r24 sei(); 38c: 78 94 sei sleep_mode(); 38e: 83 b7 in r24, 0x33 ; 51 390: 81 60 ori r24, 0x01 ; 1 392: 83 bf out 0x33, r24 ; 51 394: 88 95 sleep 396: 83 b7 in r24, 0x33 ; 51 398: 8e 7f andi r24, 0xFE ; 254 39a: 83 bf out 0x33, r24 ; 51 } 39c: 08 95 ret 0000039e : //* description: set new priority for current Task * //* input: TaskPrio (low/medium/high) * //* output: new TaskPrio * //**************************************************** uint8_t taskNewPrio(TaskPrio prio) {return current->prio = prio;} 39e: e0 91 08 01 lds r30, 0x0108 3a2: f0 91 09 01 lds r31, 0x0109 3a6: 84 83 std Z+4, r24 ; 0x04 3a8: 84 81 ldd r24, Z+4 ; 0x04 3aa: 08 95 ret 000003ac : { while (1) { wdt_reset(); set_sleep_mode(SLEEP_MODE_IDLE); TIMER_REG = _BV(CS00); 3ac: 21 e0 ldi r18, 0x01 ; 1 TCNT0 = 0xFF; 3ae: 9f ef ldi r25, 0xFF ; 255 void idle() { while (1) { wdt_reset(); 3b0: a8 95 wdr set_sleep_mode(SLEEP_MODE_IDLE); 3b2: 83 b7 in r24, 0x33 ; 51 3b4: 81 7f andi r24, 0xF1 ; 241 3b6: 83 bf out 0x33, r24 ; 51 TIMER_REG = _BV(CS00); 3b8: 25 bd out 0x25, r18 ; 37 TCNT0 = 0xFF; 3ba: 96 bd out 0x26, r25 ; 38 sleep_mode(); 3bc: 83 b7 in r24, 0x33 ; 51 3be: 81 60 ori r24, 0x01 ; 1 3c0: 83 bf out 0x33, r24 ; 51 3c2: 88 95 sleep 3c4: 83 b7 in r24, 0x33 ; 51 3c6: 8e 7f andi r24, 0xFE ; 254 3c8: 83 bf out 0x33, r24 ; 51 3ca: f2 cf rjmp .-28 ; 0x3b0 000003cc : //* description: check if memory is available * //* input: no * //* output: number of free memory blocks * //**************************************************** uint8_t memory_get_free_blocks() {return MAXBLOCKS - currentBlocks;} 3cc: 90 91 0b 01 lds r25, 0x010B 3d0: 82 e0 ldi r24, 0x02 ; 2 3d2: 89 1b sub r24, r25 3d4: 08 95 ret 000003d6 : //* output: pointer to memory block or 0 (error) * //**************************************************** void* memory_allocate_block() { sregsys = SREG; 3d6: 8f b7 in r24, 0x3f ; 63 3d8: 80 93 0a 01 sts 0x010A, r24 cli(); 3dc: f8 94 cli if (currentBlocks >= MAXBLOCKS) 3de: 80 91 0b 01 lds r24, 0x010B 3e2: 82 30 cpi r24, 0x02 ; 2 3e4: 48 f5 brcc .+82 ; 0x438 SREG = sregsys; return 0; } uint8_t a; char* ptr; mem_block_intern* block = (blocks+currentBlocks); 3e6: 90 91 0b 01 lds r25, 0x010B 3ea: 83 e0 ldi r24, 0x03 ; 3 3ec: 98 9f mul r25, r24 3ee: f0 01 movw r30, r0 3f0: 11 24 eor r1, r1 3f2: e0 5f subi r30, 0xF0 ; 240 3f4: fe 4f sbci r31, 0xFE ; 254 //insert block //set a pointer to the memory block block->ptr = data+(currentBlocks*BLOCKSIZE); 3f6: 80 91 0b 01 lds r24, 0x010B 3fa: 90 e0 ldi r25, 0x00 ; 0 3fc: 82 5f subi r24, 0xF2 ; 242 3fe: 9e 4f sbci r25, 0xFE ; 254 400: 92 83 std Z+2, r25 ; 0x02 402: 81 83 std Z+1, r24 ; 0x01 ptr = (char*) block->ptr; 404: a1 81 ldd r26, Z+1 ; 0x01 406: b2 81 ldd r27, Z+2 ; 0x02 //leave if theres not enough memory if (block->ptr == 0 || (uint16_t) block->ptr > HEAPSTART) 408: 81 81 ldd r24, Z+1 ; 0x01 40a: 92 81 ldd r25, Z+2 ; 0x02 40c: 89 2b or r24, r25 40e: a1 f0 breq .+40 ; 0x438 410: 81 81 ldd r24, Z+1 ; 0x01 412: 92 81 ldd r25, Z+2 ; 0x02 414: 80 50 subi r24, 0x00 ; 0 416: 93 40 sbci r25, 0x03 ; 3 418: 78 f4 brcc .+30 ; 0x438 SREG = sregsys; return 0; } //clear memory for (a=0;aowner = currentTask; 41c: 80 91 00 01 lds r24, 0x0100 420: 80 83 st Z, r24 currentBlocks++; 422: 80 91 0b 01 lds r24, 0x010B 426: 8f 5f subi r24, 0xFF ; 255 428: 80 93 0b 01 sts 0x010B, r24 SREG = sregsys; 42c: 80 91 0a 01 lds r24, 0x010A 430: 8f bf out 0x3f, r24 ; 63 //return pointer to memory block return (void*) block->ptr; 432: 21 81 ldd r18, Z+1 ; 0x01 434: 32 81 ldd r19, Z+2 ; 0x02 436: 05 c0 rjmp .+10 ; 0x442 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; 438: 80 91 0a 01 lds r24, 0x010A 43c: 8f bf out 0x3f, r24 ; 63 43e: 20 e0 ldi r18, 0x00 ; 0 440: 30 e0 ldi r19, 0x00 ; 0 block->owner = currentTask; currentBlocks++; SREG = sregsys; //return pointer to memory block return (void*) block->ptr; } 442: c9 01 movw r24, r18 444: 08 95 ret 00000446 : //* input: pointer to allocated memory block * //* output: TRUE (ok) or ZERO (error) * //**************************************************** uint8_t memory_free_block(void* ptr) { 446: 9c 01 movw r18, r24 sregsys = SREG; 448: 8f b7 in r24, 0x3f ; 63 44a: 80 93 0a 01 sts 0x010A, r24 cli(); 44e: f8 94 cli 450: 40 e0 ldi r20, 0x00 ; 0 uint8_t a,b; //search for correct memory block for (a=0;aptr == ptr) 452: 53 e0 ldi r21, 0x03 ; 3 454: 47 c0 rjmp .+142 ; 0x4e4 456: 45 9f mul r20, r21 458: f0 01 movw r30, r0 45a: 11 24 eor r1, r1 45c: e0 5f subi r30, 0xF0 ; 240 45e: fe 4f sbci r31, 0xFE ; 254 460: 81 81 ldd r24, Z+1 ; 0x01 462: 92 81 ldd r25, Z+2 ; 0x02 464: 82 17 cp r24, r18 466: 93 07 cpc r25, r19 468: e1 f5 brne .+120 ; 0x4e2 { if ((blocks+a)->owner != currentTask) 46a: 20 81 ld r18, Z 46c: 80 91 00 01 lds r24, 0x0100 470: 30 e0 ldi r19, 0x00 ; 0 472: 99 27 eor r25, r25 474: 87 fd sbrc r24, 7 476: 90 95 com r25 478: 28 17 cp r18, r24 47a: 39 07 cpc r19, r25 47c: 29 f0 breq .+10 ; 0x488 { SREG = sregsys; 47e: 80 91 0a 01 lds r24, 0x010A 482: 8f bf out 0x3f, r24 ; 63 484: 80 e0 ldi r24, 0x00 ; 0 486: 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; 488: 12 82 std Z+2, r1 ; 0x02 48a: 11 82 std Z+1, r1 ; 0x01 (blocks+a)->owner=0; 48c: 10 82 st Z, r1 48e: 16 c0 rjmp .+44 ; 0x4bc //re-organize memory blocks for (b=a;b<(currentBlocks-1);b++) blocks[b]=blocks[b+1]; 490: c9 01 movw r24, r18 492: 01 96 adiw r24, 0x01 ; 1 494: d9 01 movw r26, r18 496: aa 0f add r26, r26 498: bb 1f adc r27, r27 49a: a2 0f add r26, r18 49c: b3 1f adc r27, r19 49e: fc 01 movw r30, r24 4a0: ee 0f add r30, r30 4a2: ff 1f adc r31, r31 4a4: e8 0f add r30, r24 4a6: f9 1f adc r31, r25 4a8: a0 5f subi r26, 0xF0 ; 240 4aa: be 4f sbci r27, 0xFE ; 254 4ac: e0 5f subi r30, 0xF0 ; 240 4ae: fe 4f sbci r31, 0xFE ; 254 4b0: 83 e0 ldi r24, 0x03 ; 3 4b2: 01 90 ld r0, Z+ 4b4: 0d 92 st X+, r0 4b6: 81 50 subi r24, 0x01 ; 1 4b8: e1 f7 brne .-8 ; 0x4b2 //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++) 4ba: 4f 5f subi r20, 0xFF ; 255 4bc: 24 2f mov r18, r20 4be: 30 e0 ldi r19, 0x00 ; 0 4c0: 80 91 0b 01 lds r24, 0x010B 4c4: 90 e0 ldi r25, 0x00 ; 0 4c6: 01 97 sbiw r24, 0x01 ; 1 4c8: 28 17 cp r18, r24 4ca: 39 07 cpc r19, r25 4cc: 0c f3 brlt .-62 ; 0x490 blocks[b]=blocks[b+1]; currentBlocks--; 4ce: 80 91 0b 01 lds r24, 0x010B 4d2: 81 50 subi r24, 0x01 ; 1 4d4: 80 93 0b 01 sts 0x010B, r24 SREG = sregsys; 4d8: 80 91 0a 01 lds r24, 0x010A 4dc: 8f bf out 0x3f, r24 ; 63 4de: 81 e0 ldi r24, 0x01 ; 1 4e0: 08 95 ret { sregsys = SREG; cli(); uint8_t a,b; //search for correct memory block for (a=0;a 4ec: b4 cf rjmp .-152 ; 0x456 currentBlocks--; SREG = sregsys; return TRUE; } } SREG = sregsys; 4ee: 80 91 0a 01 lds r24, 0x010A 4f2: 8f bf out 0x3f, r24 ; 63 4f4: 80 e0 ldi r24, 0x00 ; 0 return 0; } 4f6: 08 95 ret 000004f8 : //* input: Queue *qp: Pointer to queue * //* output: free places in the queue * //**************************************************** uint8_t queue_exists(Queue *qp) { 4f8: fc 01 movw r30, r24 if (qp->queueDepth) 4fa: 81 81 ldd r24, Z+1 ; 0x01 4fc: 81 11 cpse r24, r1 4fe: 81 e0 ldi r24, 0x01 ; 1 return TRUE; return 0; } 500: 08 95 ret 00000502 : //* input: Queue *qp: Pointer to queue * //* output: maximum number of messages in the queue * //**************************************************** uint8_t queue_get_maximum_size(Queue *qp) { 502: fc 01 movw r30, r24 return qp->queueDepth; 504: 81 81 ldd r24, Z+1 ; 0x01 } 506: 08 95 ret 00000508 : //* input: Pointer to queue * //* output: free places in the queue * //**************************************************** uint8_t queue_get_free_size(Queue *qp) { 508: fc 01 movw r30, r24 return qp->queueDepth - qp->number; 50a: 81 81 ldd r24, Z+1 ; 0x01 50c: 92 81 ldd r25, Z+2 ; 0x02 } 50e: 89 1b sub r24, r25 510: 08 95 ret 00000512 : //* input: Queue *qp: Pointer to queue * //* output: number of messages in the queue * //**************************************************** uint8_t queue_get_mumber_of_messages(Queue *qp) { 512: fc 01 movw r30, r24 return qp->number; 514: 82 81 ldd r24, Z+2 ; 0x02 } 516: 08 95 ret 00000518 : //* input: Queue *qp: Pointer to queue * //* output: TRUE (new message), ZERO (error) * //**************************************************** uint8_t queue_wait_for_message(Queue *qp) { 518: fc 01 movw r30, r24 //enable multitasking to avoid a deadrun wdt_enable(WDTO_2S); 51a: 2f e0 ldi r18, 0x0F ; 15 51c: 88 e1 ldi r24, 0x18 ; 24 51e: 90 e0 ldi r25, 0x00 ; 0 520: 0f b6 in r0, 0x3f ; 63 522: f8 94 cli 524: a8 95 wdr 526: 80 93 60 00 sts 0x0060, r24 52a: 0f be out 0x3f, r0 ; 63 52c: 20 93 60 00 sts 0x0060, r18 TIMER_ENABLE |= _BV(TOIE0); 530: 80 91 6e 00 lds r24, 0x006E 534: 81 60 ori r24, 0x01 ; 1 536: 80 93 6e 00 sts 0x006E, r24 sei(); 53a: 78 94 sei if (qp->queueDepth == 0) 53c: 81 81 ldd r24, Z+1 ; 0x01 53e: 88 23 and r24, r24 540: 19 f4 brne .+6 ; 0x548 542: 08 95 ret return 0; while (qp->number == 0) TCNT0=0xFF; 544: 96 bd out 0x26, r25 ; 38 546: 01 c0 rjmp .+2 ; 0x54a 548: 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) 54a: 82 81 ldd r24, Z+2 ; 0x02 54c: 88 23 and r24, r24 54e: d1 f3 breq .-12 ; 0x544 550: 81 e0 ldi r24, 0x01 ; 1 TCNT0=0xFF; return TRUE; } 552: 08 95 ret 00000554 : //* Works only with 1-byte-item Queues! * //* * //*********************************************************************** unsigned char queue_read_byte(Queue *qp, uint8_t position, uint8_t delete_message) { 554: cf 93 push r28 556: df 93 push r29 558: ec 01 movw r28, r24 sregsys = SREG; 55a: 8f b7 in r24, 0x3f ; 63 55c: 80 93 0a 01 sts 0x010A, r24 cli(); 560: f8 94 cli uint8_t i; unsigned char tempmsg; if (qp->number == 0 || qp->number <= position || qp->item_size != 1) 562: 8a 81 ldd r24, Y+2 ; 0x02 564: 88 23 and r24, r24 566: 31 f0 breq .+12 ; 0x574 568: 8a 81 ldd r24, Y+2 ; 0x02 56a: 68 17 cp r22, r24 56c: 18 f4 brcc .+6 ; 0x574 56e: 88 81 ld r24, Y 570: 81 30 cpi r24, 0x01 ; 1 572: 21 f0 breq .+8 ; 0x57c { SREG = sregsys; 574: 80 91 0a 01 lds r24, 0x010A 578: 8f bf out 0x3f, r24 ; 63 57a: 24 c0 rjmp .+72 ; 0x5c4 return; } //read message tempmsg = qp->message[position]; 57c: ed 81 ldd r30, Y+5 ; 0x05 57e: fe 81 ldd r31, Y+6 ; 0x06 580: e6 0f add r30, r22 582: f1 1d adc r31, r1 584: 50 81 ld r21, Z if (delete_message) 586: 44 23 and r20, r20 588: 71 f4 brne .+28 ; 0x5a6 58a: 18 c0 rjmp .+48 ; 0x5bc { //re-organize message queue (FIFO) for (i=position;i<(qp->number)-1;i++) qp->message[i] = qp->message[i+1]; 58c: ed 81 ldd r30, Y+5 ; 0x05 58e: fe 81 ldd r31, Y+6 ; 0x06 590: e2 0f add r30, r18 592: f3 1f adc r31, r19 594: ad 81 ldd r26, Y+5 ; 0x05 596: be 81 ldd r27, Y+6 ; 0x06 598: 2f 5f subi r18, 0xFF ; 255 59a: 3f 4f sbci r19, 0xFF ; 255 59c: a2 0f add r26, r18 59e: b3 1f adc r27, r19 5a0: 8c 91 ld r24, X 5a2: 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++) 5a4: 6f 5f subi r22, 0xFF ; 255 5a6: 8a 81 ldd r24, Y+2 ; 0x02 5a8: 26 2f mov r18, r22 5aa: 30 e0 ldi r19, 0x00 ; 0 5ac: 90 e0 ldi r25, 0x00 ; 0 5ae: 01 97 sbiw r24, 0x01 ; 1 5b0: 28 17 cp r18, r24 5b2: 39 07 cpc r19, r25 5b4: 5c f3 brlt .-42 ; 0x58c qp->message[i] = qp->message[i+1]; qp->number--; 5b6: 8a 81 ldd r24, Y+2 ; 0x02 5b8: 81 50 subi r24, 0x01 ; 1 5ba: 8a 83 std Y+2, r24 ; 0x02 } SREG = sregsys; 5bc: 80 91 0a 01 lds r24, 0x010A 5c0: 8f bf out 0x3f, r24 ; 63 5c2: 85 2f mov r24, r21 return tempmsg; } 5c4: df 91 pop r29 5c6: cf 91 pop r28 5c8: 08 95 ret 000005ca : } } //this is the display task for the hours void display_hours() { 5ca: cf 93 push r28 5cc: df 93 push r29 //* output: free places in the queue * //**************************************************** uint8_t queue_exists(Queue *qp) { if (qp->queueDepth) 5ce: 80 91 c8 01 lds r24, 0x01C8 5d2: 88 23 and r24, r24 5d4: 21 f0 breq .+8 ; 0x5de //* description: check if memory is available * //* input: no * //* output: number of free memory blocks * //**************************************************** uint8_t memory_get_free_blocks() {return MAXBLOCKS - currentBlocks;} 5d6: 80 91 0b 01 lds r24, 0x010B if (!(queue_exists(&hours_queue)) || !(memory_get_free_blocks())) 5da: 82 30 cpi r24, 0x02 ; 2 5dc: 21 f4 brne .+8 ; 0x5e6 task_anhilate(&display_hours_task); 5de: 8e ec ldi r24, 0xCE ; 206 5e0: 91 e0 ldi r25, 0x01 ; 1 5e2: 0e 94 39 01 call 0x272 ; 0x272 unsigned char* hrs_ptr = memory_allocate_block(); 5e6: 0e 94 eb 01 call 0x3d6 ; 0x3d6 5ea: ec 01 movw r28, r24 while (1) { //Wait for new hour message queue_wait_for_message(&hours_queue); 5ec: 87 ec ldi r24, 0xC7 ; 199 5ee: 91 e0 ldi r25, 0x01 ; 1 5f0: 0e 94 8c 02 call 0x518 ; 0x518 //set PORTC to new hour value *hrs_ptr = queue_read_byte(&hours_queue,0,1); 5f4: 87 ec ldi r24, 0xC7 ; 199 5f6: 91 e0 ldi r25, 0x01 ; 1 5f8: 60 e0 ldi r22, 0x00 ; 0 5fa: 41 e0 ldi r20, 0x01 ; 1 5fc: 0e 94 aa 02 call 0x554 ; 0x554 600: 88 83 st Y, r24 PORTC = *hrs_ptr; 602: 88 b9 out 0x08, r24 ; 8 604: f3 cf rjmp .-26 ; 0x5ec 00000606 : //+++Task functions+++ //this is the display task for the minutes void display_minutes() { 606: cf 93 push r28 608: df 93 push r29 60a: 80 91 14 02 lds r24, 0x0214 60e: 88 23 and r24, r24 610: 21 f0 breq .+8 ; 0x61a 612: 80 91 0b 01 lds r24, 0x010B if (!(queue_exists(&minutes_queue)) || !(memory_get_free_blocks())) 616: 82 30 cpi r24, 0x02 ; 2 618: 21 f4 brne .+8 ; 0x622 task_anhilate(&display_minutes_task); 61a: 82 e8 ldi r24, 0x82 ; 130 61c: 91 e0 ldi r25, 0x01 ; 1 61e: 0e 94 39 01 call 0x272 ; 0x272 unsigned char* min_ptr = memory_allocate_block(); 622: 0e 94 eb 01 call 0x3d6 ; 0x3d6 626: ec 01 movw r28, r24 while (1) { //Wait for new minute message queue_wait_for_message(&minutes_queue); 628: 83 e1 ldi r24, 0x13 ; 19 62a: 92 e0 ldi r25, 0x02 ; 2 62c: 0e 94 8c 02 call 0x518 ; 0x518 //set PORTD to new minute value *min_ptr = queue_read_byte(&minutes_queue,0,1); 630: 83 e1 ldi r24, 0x13 ; 19 632: 92 e0 ldi r25, 0x02 ; 2 634: 60 e0 ldi r22, 0x00 ; 0 636: 41 e0 ldi r20, 0x01 ; 1 638: 0e 94 aa 02 call 0x554 ; 0x554 63c: 88 83 st Y, r24 PORTD = *min_ptr; 63e: 8b b9 out 0x0b, r24 ; 11 640: f3 cf rjmp .-26 ; 0x628 00000642 : //* 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) { 642: ef 92 push r14 644: ff 92 push r15 646: 0f 93 push r16 648: 1f 93 push r17 64a: cf 93 push r28 64c: df 93 push r29 64e: ec 01 movw r28, r24 650: 8b 01 movw r16, r22 652: 94 2f mov r25, r20 654: e2 2e mov r14, r18 sregsys = SREG; 656: 8f b7 in r24, 0x3f ; 63 658: 80 93 0a 01 sts 0x010A, r24 cli(); 65c: f8 94 cli uint8_t i,j; position = position * qp->item_size; // get correct message for the given entry. 65e: 48 81 ld r20, Y if (qp->number == 0 || qp->number <= position || targetpointer == 0) 660: 8a 81 ldd r24, Y+2 ; 0x02 662: 88 23 and r24, r24 664: 69 f0 breq .+26 ; 0x680 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. 666: 94 9f mul r25, r20 668: 40 2d mov r20, r0 66a: 11 24 eor r1, r1 if (qp->number == 0 || qp->number <= position || targetpointer == 0) 66c: 8a 81 ldd r24, Y+2 ; 0x02 66e: 48 17 cp r20, r24 670: 38 f4 brcc .+14 ; 0x680 672: 61 15 cp r22, r1 674: 71 05 cpc r23, r1 676: 21 f0 breq .+8 ; 0x680 678: f4 2e mov r15, r20 { SREG = sregsys; return 0; } //read messages for (i=position;i<(position+qp->item_size);i++) 67a: 64 2f mov r22, r20 67c: 70 e0 ldi r23, 0x00 ; 0 67e: 36 c0 rjmp .+108 ; 0x6ec 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; 680: 80 91 0a 01 lds r24, 0x010A 684: 8f bf out 0x3f, r24 ; 63 686: 80 e0 ldi r24, 0x00 ; 0 688: 3e c0 rjmp .+124 ; 0x706 68a: d9 01 movw r26, r18 68c: a6 1b sub r26, r22 68e: b7 0b sbc r27, r23 return 0; } //read messages for (i=position;i<(position+qp->item_size);i++) { if (delete_message) 690: ee 20 and r14, r14 692: 19 f1 breq .+70 ; 0x6da { *(targetpointer+(i-position)) = qp->message[position]; 694: ed 81 ldd r30, Y+5 ; 0x05 696: fe 81 ldd r31, Y+6 ; 0x06 698: e6 0f add r30, r22 69a: f7 1f adc r31, r23 69c: 80 81 ld r24, Z 69e: a0 0f add r26, r16 6a0: b1 1f adc r27, r17 6a2: 8c 93 st X, r24 6a4: 54 2f mov r21, r20 6a6: 0d c0 rjmp .+26 ; 0x6c2 //re-organize message queue (FIFO) for (j=position;j<(qp->number)-1;j++) qp->message[j] = qp->message[j+1]; 6a8: ed 81 ldd r30, Y+5 ; 0x05 6aa: fe 81 ldd r31, Y+6 ; 0x06 6ac: e2 0f add r30, r18 6ae: f3 1f adc r31, r19 6b0: ad 81 ldd r26, Y+5 ; 0x05 6b2: be 81 ldd r27, Y+6 ; 0x06 6b4: 2f 5f subi r18, 0xFF ; 255 6b6: 3f 4f sbci r19, 0xFF ; 255 6b8: a2 0f add r26, r18 6ba: b3 1f adc r27, r19 6bc: 8c 91 ld r24, X 6be: 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++) 6c0: 5f 5f subi r21, 0xFF ; 255 6c2: 8a 81 ldd r24, Y+2 ; 0x02 6c4: 25 2f mov r18, r21 6c6: 30 e0 ldi r19, 0x00 ; 0 6c8: 90 e0 ldi r25, 0x00 ; 0 6ca: 01 97 sbiw r24, 0x01 ; 1 6cc: 28 17 cp r18, r24 6ce: 39 07 cpc r19, r25 6d0: 5c f3 brlt .-42 ; 0x6a8 qp->message[j] = qp->message[j+1]; qp->number--; 6d2: 8a 81 ldd r24, Y+2 ; 0x02 6d4: 81 50 subi r24, 0x01 ; 1 6d6: 8a 83 std Y+2, r24 ; 0x02 6d8: 08 c0 rjmp .+16 ; 0x6ea } else *(targetpointer+(i-position)) = qp->message[i]; 6da: ed 81 ldd r30, Y+5 ; 0x05 6dc: fe 81 ldd r31, Y+6 ; 0x06 6de: e2 0f add r30, r18 6e0: f3 1f adc r31, r19 6e2: 80 81 ld r24, Z 6e4: a0 0f add r26, r16 6e6: b1 1f adc r27, r17 6e8: 8c 93 st X, r24 { SREG = sregsys; return 0; } //read messages for (i=position;i<(position+qp->item_size);i++) 6ea: f3 94 inc r15 6ec: 2f 2d mov r18, r15 6ee: 30 e0 ldi r19, 0x00 ; 0 6f0: 88 81 ld r24, Y 6f2: fb 01 movw r30, r22 6f4: e8 0f add r30, r24 6f6: f1 1d adc r31, r1 6f8: 2e 17 cp r18, r30 6fa: 3f 07 cpc r19, r31 6fc: 34 f2 brlt .-116 ; 0x68a qp->number--; } else *(targetpointer+(i-position)) = qp->message[i]; } SREG = sregsys; 6fe: 80 91 0a 01 lds r24, 0x010A 702: 8f bf out 0x3f, r24 ; 63 704: 81 e0 ldi r24, 0x01 ; 1 return TRUE; } 706: df 91 pop r29 708: cf 91 pop r28 70a: 1f 91 pop r17 70c: 0f 91 pop r16 70e: ff 90 pop r15 710: ef 90 pop r14 712: 08 95 ret 00000714 : //* input: Queue *qp: Pointer to queue * //* output: Pointer * //*********************************************** void* queue_read_pointer (Queue *qp) { 714: fc 01 movw r30, r24 return (void*) qp->ptr; 716: 23 81 ldd r18, Z+3 ; 0x03 718: 34 81 ldd r19, Z+4 ; 0x04 } 71a: c9 01 movw r24, r18 71c: 08 95 ret 0000071e : //* Works only with 1-byte-item Queues! * //* * //**************************************************** uint8_t queue_write_byte (Queue *qp, unsigned char message) { 71e: dc 01 movw r26, r24 sregsys = SREG; 720: 8f b7 in r24, 0x3f ; 63 722: 80 93 0a 01 sts 0x010A, r24 cli(); 726: f8 94 cli uint8_t mlen = qp->number; 728: 12 96 adiw r26, 0x02 ; 2 72a: 2c 91 ld r18, X 72c: 12 97 sbiw r26, 0x02 ; 2 if (mlen > (qp->queueDepth - 1) || qp->item_size != 1) 72e: 11 96 adiw r26, 0x01 ; 1 730: 8c 91 ld r24, X 732: 11 97 sbiw r26, 0x01 ; 1 734: 90 e0 ldi r25, 0x00 ; 0 736: 30 e0 ldi r19, 0x00 ; 0 738: 28 17 cp r18, r24 73a: 39 07 cpc r19, r25 73c: 1c f4 brge .+6 ; 0x744 73e: 8c 91 ld r24, X 740: 81 30 cpi r24, 0x01 ; 1 742: 29 f0 breq .+10 ; 0x74e { SREG = sregsys; 744: 80 91 0a 01 lds r24, 0x010A 748: 8f bf out 0x3f, r24 ; 63 74a: 80 e0 ldi r24, 0x00 ; 0 74c: 08 95 ret return 0; } //insert message qp->message[mlen]=message; 74e: 15 96 adiw r26, 0x05 ; 5 750: ed 91 ld r30, X+ 752: fc 91 ld r31, X 754: 16 97 sbiw r26, 0x06 ; 6 756: e2 0f add r30, r18 758: f3 1f adc r31, r19 75a: 60 83 st Z, r22 qp->number++; 75c: 12 96 adiw r26, 0x02 ; 2 75e: 8c 91 ld r24, X 760: 12 97 sbiw r26, 0x02 ; 2 762: 8f 5f subi r24, 0xFF ; 255 764: 12 96 adiw r26, 0x02 ; 2 766: 8c 93 st X, r24 SREG = sregsys; 768: 80 91 0a 01 lds r24, 0x010A 76c: 8f bf out 0x3f, r24 ; 63 76e: 81 e0 ldi r24, 0x01 ; 1 return TRUE; } 770: 08 95 ret 00000772 : //ISR for Pin Change Interrupts - Buttons void button_press_12() { // button1 is pressed if (! (PINB & _BV(PB1))) 772: 19 99 sbic 0x03, 1 ; 3 774: 0b c0 rjmp .+22 ; 0x78c { //disable interrupt fpr debounce PCMSK0 &= ~_BV(PCINT1); 776: 80 91 6b 00 lds r24, 0x006B 77a: 8d 7f andi r24, 0xFD ; 253 77c: 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); 780: 86 e3 ldi r24, 0x36 ; 54 782: 91 e0 ldi r25, 0x01 ; 1 784: 61 e0 ldi r22, 0x01 ; 1 786: 0e 94 8f 03 call 0x71e ; 0x71e 78a: 08 95 ret return; } // button2 is pressed if (! (PINB & _BV(PB2))) 78c: 1a 99 sbic 0x03, 2 ; 3 78e: 0a c0 rjmp .+20 ; 0x7a4 { //disable interrupt fpr debounce PCMSK0 &= ~_BV(PCINT2); 790: 80 91 6b 00 lds r24, 0x006B 794: 8b 7f andi r24, 0xFB ; 251 796: 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); 79a: 86 e3 ldi r24, 0x36 ; 54 79c: 91 e0 ldi r25, 0x01 ; 1 79e: 62 e0 ldi r22, 0x02 ; 2 7a0: 0e 94 8f 03 call 0x71e ; 0x71e 7a4: 08 95 ret 000007a6 <__vector_3>: { tick_time(); } SIGNAL(SIG_PIN_CHANGE0) { 7a6: 1f 92 push r1 7a8: 0f 92 push r0 7aa: 0f b6 in r0, 0x3f ; 63 7ac: 0f 92 push r0 7ae: 11 24 eor r1, r1 7b0: 2f 93 push r18 7b2: 3f 93 push r19 7b4: 4f 93 push r20 7b6: 5f 93 push r21 7b8: 6f 93 push r22 7ba: 7f 93 push r23 7bc: 8f 93 push r24 7be: 9f 93 push r25 7c0: af 93 push r26 7c2: bf 93 push r27 7c4: ef 93 push r30 7c6: ff 93 push r31 button_press_12(); 7c8: 0e 94 b9 03 call 0x772 ; 0x772 } 7cc: ff 91 pop r31 7ce: ef 91 pop r30 7d0: bf 91 pop r27 7d2: af 91 pop r26 7d4: 9f 91 pop r25 7d6: 8f 91 pop r24 7d8: 7f 91 pop r23 7da: 6f 91 pop r22 7dc: 5f 91 pop r21 7de: 4f 91 pop r20 7e0: 3f 91 pop r19 7e2: 2f 91 pop r18 7e4: 0f 90 pop r0 7e6: 0f be out 0x3f, r0 ; 63 7e8: 0f 90 pop r0 7ea: 1f 90 pop r1 7ec: 18 95 reti 000007ee : //ISR for Timer2 - Clock timer void tick_time() { static uint8_t zaehler; zaehler++; 7ee: 80 91 0c 01 lds r24, 0x010C 7f2: 8f 5f subi r24, 0xFF ; 255 7f4: 80 93 0c 01 sts 0x010C, r24 if (zaehler == 122) //Interrupt is called @ 8 Mhz / (256*256) = 122 times per second 7f8: 8a 37 cpi r24, 0x7A ; 122 7fa: 41 f4 brne .+16 ; 0x80c { //we have a new second so send a message to time_calc task; zaehler = 0; 7fc: 10 92 0c 01 sts 0x010C, r1 queue_write_byte(&time_calc_queue, 128); //anything but 1 or 2 800: 86 e3 ldi r24, 0x36 ; 54 802: 91 e0 ldi r25, 0x01 ; 1 804: 60 e8 ldi r22, 0x80 ; 128 806: 0e 94 8f 03 call 0x71e ; 0x71e 80a: 08 95 ret } //debounce for buttons (enable button interrupts again after 0,3 seconds; else if (!(zaehler % 30)) 80c: 6e e1 ldi r22, 0x1E ; 30 80e: 0e 94 8c 05 call 0xb18 ; 0xb18 <__udivmodqi4> 812: 99 23 and r25, r25 814: 51 f4 brne .+20 ; 0x82a { PCMSK0 |= _BV(PCINT1); 816: 80 91 6b 00 lds r24, 0x006B 81a: 82 60 ori r24, 0x02 ; 2 81c: 80 93 6b 00 sts 0x006B, r24 PCMSK0 |= _BV(PCINT2); 820: 80 91 6b 00 lds r24, 0x006B 824: 84 60 ori r24, 0x04 ; 4 826: 80 93 6b 00 sts 0x006B, r24 82a: 08 95 ret 0000082c <__vector_9>: void button_press_12(void); //Interrupt Handler SIGNAL (TIMER2_OVF_vect) { 82c: 1f 92 push r1 82e: 0f 92 push r0 830: 0f b6 in r0, 0x3f ; 63 832: 0f 92 push r0 834: 11 24 eor r1, r1 836: 2f 93 push r18 838: 3f 93 push r19 83a: 4f 93 push r20 83c: 5f 93 push r21 83e: 6f 93 push r22 840: 7f 93 push r23 842: 8f 93 push r24 844: 9f 93 push r25 846: af 93 push r26 848: bf 93 push r27 84a: ef 93 push r30 84c: ff 93 push r31 tick_time(); 84e: 0e 94 f7 03 call 0x7ee ; 0x7ee } 852: ff 91 pop r31 854: ef 91 pop r30 856: bf 91 pop r27 858: af 91 pop r26 85a: 9f 91 pop r25 85c: 8f 91 pop r24 85e: 7f 91 pop r23 860: 6f 91 pop r22 862: 5f 91 pop r21 864: 4f 91 pop r20 866: 3f 91 pop r19 868: 2f 91 pop r18 86a: 0f 90 pop r0 86c: 0f be out 0x3f, r0 ; 63 86e: 0f 90 pop r0 870: 1f 90 pop r1 872: 18 95 reti 00000874 : } } //this calculates the time void time_calc() { 874: df 92 push r13 876: ef 92 push r14 878: ff 92 push r15 87a: 0f 93 push r16 87c: 1f 93 push r17 87e: cf 93 push r28 880: df 93 push r29 m = 0; } // else it must be a new second else { TASK_ENTER_CRITICAL; 882: 78 e1 ldi r23, 0x18 ; 24 884: d7 2e mov r13, r23 h++; if (h == 24) h = 0; } } TASK_LEAVE_CRITICAL; 886: c8 e1 ldi r28, 0x18 ; 24 888: d0 e0 ldi r29, 0x00 ; 0 88a: 6f e0 ldi r22, 0x0F ; 15 88c: 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); 88e: 86 e3 ldi r24, 0x36 ; 54 890: 91 e0 ldi r25, 0x01 ; 1 892: 0e 94 8c 02 call 0x518 ; 0x518 calc_msg = queue_read_byte(&time_calc_queue,0,1); 896: 86 e3 ldi r24, 0x36 ; 54 898: 91 e0 ldi r25, 0x01 ; 1 89a: 60 e0 ldi r22, 0x00 ; 0 89c: 41 e0 ldi r20, 0x01 ; 1 89e: 0e 94 aa 02 call 0x554 ; 0x554 // if button 1 is pressed increase hours if (calc_msg == 1) 8a2: 81 30 cpi r24, 0x01 ; 1 8a4: 31 f4 brne .+12 ; 0x8b2 { if (h < 23) 8a6: 07 31 cpi r16, 0x17 ; 23 8a8: 10 f0 brcs .+4 ; 0x8ae 8aa: 00 e0 ldi r16, 0x00 ; 0 8ac: 2e c0 rjmp .+92 ; 0x90a h++; 8ae: 0f 5f subi r16, 0xFF ; 255 8b0: 2c c0 rjmp .+88 ; 0x90a else h = 0; } // if button 2 is pressed increase minutes else if (calc_msg == 2) 8b2: 82 30 cpi r24, 0x02 ; 2 8b4: 31 f4 brne .+12 ; 0x8c2 { if (m < 59) 8b6: 1b 33 cpi r17, 0x3B ; 59 8b8: 10 f0 brcs .+4 ; 0x8be 8ba: 10 e0 ldi r17, 0x00 ; 0 8bc: 26 c0 rjmp .+76 ; 0x90a m++; 8be: 1f 5f subi r17, 0xFF ; 255 8c0: 24 c0 rjmp .+72 ; 0x90a m = 0; } // else it must be a new second else { TASK_ENTER_CRITICAL; 8c2: 8f b7 in r24, 0x3f ; 63 8c4: 80 93 0d 01 sts 0x010D, r24 8c8: 0f b6 in r0, 0x3f ; 63 8ca: f8 94 cli 8cc: d0 92 60 00 sts 0x0060, r13 8d0: 10 92 60 00 sts 0x0060, r1 8d4: 0f be out 0x3f, r0 ; 63 8d6: f8 94 cli s++; 8d8: f3 94 inc r15 if (s == 60) 8da: 8c e3 ldi r24, 0x3C ; 60 8dc: f8 16 cp r15, r24 8de: 49 f4 brne .+18 ; 0x8f2 { s = 0; m++; 8e0: 1f 5f subi r17, 0xFF ; 255 if (m == 60) 8e2: 1c 33 cpi r17, 0x3C ; 60 8e4: 29 f4 brne .+10 ; 0x8f0 { m = 0; h++; 8e6: 0f 5f subi r16, 0xFF ; 255 if (h == 24) 8e8: 08 31 cpi r16, 0x18 ; 24 8ea: 09 f4 brne .+2 ; 0x8ee 8ec: 00 e0 ldi r16, 0x00 ; 0 8ee: 10 e0 ldi r17, 0x00 ; 0 8f0: ff 24 eor r15, r15 h = 0; } } TASK_LEAVE_CRITICAL; 8f2: 78 94 sei 8f4: 0f b6 in r0, 0x3f ; 63 8f6: f8 94 cli 8f8: a8 95 wdr 8fa: c0 93 60 00 sts 0x0060, r28 8fe: 0f be out 0x3f, r0 ; 63 900: e0 92 60 00 sts 0x0060, r14 904: 80 91 0d 01 lds r24, 0x010D 908: 8f bf out 0x3f, r24 ; 63 } //send time to display tasks; queue_write_byte(&minutes_queue,m); 90a: 83 e1 ldi r24, 0x13 ; 19 90c: 92 e0 ldi r25, 0x02 ; 2 90e: 61 2f mov r22, r17 910: 0e 94 8f 03 call 0x71e ; 0x71e queue_write_byte(&hours_queue,h); 914: 87 ec ldi r24, 0xC7 ; 199 916: 91 e0 ldi r25, 0x01 ; 1 918: 60 2f mov r22, r16 91a: 0e 94 8f 03 call 0x71e ; 0x71e 91e: b7 cf rjmp .-146 ; 0x88e 00000920 : //* * //* output: TRUE(ok), ZERO (error) * //******************************************************************* uint8_t queue_write_item (Queue *qp, void* startpointer) { 920: cf 93 push r28 922: df 93 push r29 924: dc 01 movw r26, r24 926: eb 01 movw r28, r22 sregsys = SREG; 928: 8f b7 in r24, 0x3f ; 63 92a: 80 93 0a 01 sts 0x010A, r24 cli(); 92e: f8 94 cli uint8_t mlen = qp->number,i=0; 930: 12 96 adiw r26, 0x02 ; 2 932: 2c 91 ld r18, X 934: 12 97 sbiw r26, 0x02 ; 2 uint8_t length = qp->item_size; 936: 6c 91 ld r22, X if (mlen + length > qp->queueDepth) 938: 11 96 adiw r26, 0x01 ; 1 93a: 8c 91 ld r24, X 93c: 11 97 sbiw r26, 0x01 ; 1 93e: 42 2f mov r20, r18 940: 50 e0 ldi r21, 0x00 ; 0 942: 9a 01 movw r18, r20 944: 26 0f add r18, r22 946: 31 1d adc r19, r1 948: 90 e0 ldi r25, 0x00 ; 0 94a: 82 17 cp r24, r18 94c: 93 07 cpc r25, r19 94e: 1c f0 brlt .+6 ; 0x956 950: 9a 01 movw r18, r20 952: 90 e0 ldi r25, 0x00 ; 0 954: 17 c0 rjmp .+46 ; 0x984 { SREG = sregsys; 956: 80 91 0a 01 lds r24, 0x010A 95a: 8f bf out 0x3f, r24 ; 63 95c: 80 e0 ldi r24, 0x00 ; 0 95e: 18 c0 rjmp .+48 ; 0x990 return 0; } //insert message as 1-byte chunks for (i=0;imessage[mlen+i]=*((unsigned char*)startpointer++); 960: 15 96 adiw r26, 0x05 ; 5 962: ed 91 ld r30, X+ 964: fc 91 ld r31, X 966: 16 97 sbiw r26, 0x06 ; 6 968: e2 0f add r30, r18 96a: f3 1f adc r31, r19 96c: 89 91 ld r24, Y+ 96e: 80 83 st Z, r24 qp->number++; 970: 12 96 adiw r26, 0x02 ; 2 972: 8c 91 ld r24, X 974: 12 97 sbiw r26, 0x02 ; 2 976: 8f 5f subi r24, 0xFF ; 255 978: 12 96 adiw r26, 0x02 ; 2 97a: 8c 93 st X, r24 97c: 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; 988: 80 91 0a 01 lds r24, 0x010A 98c: 8f bf out 0x3f, r24 ; 63 98e: 81 e0 ldi r24, 0x01 ; 1 return TRUE; } 990: df 91 pop r29 992: cf 91 pop r28 994: 08 95 ret 00000996 : //* void* Pointer: pointer to begin of word * //* output: TRUE(ok), ZERO (error) * //******************************************************* uint8_t queue_write_pointer (Queue *qp, void* pointer) { 996: fc 01 movw r30, r24 sregsys = SREG; 998: 8f b7 in r24, 0x3f ; 63 99a: 80 93 0a 01 sts 0x010A, r24 cli(); 99e: f8 94 cli if (pointer == 0) 9a0: 61 15 cp r22, r1 9a2: 71 05 cpc r23, r1 9a4: 29 f4 brne .+10 ; 0x9b0 { SREG = sregsys; 9a6: 80 91 0a 01 lds r24, 0x010A 9aa: 8f bf out 0x3f, r24 ; 63 9ac: 80 e0 ldi r24, 0x00 ; 0 9ae: 08 95 ret return 0; } //insert pointer qp->ptr = pointer; 9b0: 74 83 std Z+4, r23 ; 0x04 9b2: 63 83 std Z+3, r22 ; 0x03 SREG = sregsys; 9b4: 80 91 0a 01 lds r24, 0x010A 9b8: 8f bf out 0x3f, r24 ; 63 9ba: 81 e0 ldi r24, 0x01 ; 1 return TRUE; } 9bc: 08 95 ret 000009be : //* input: Queue *qp: Pointer to queue * //* output: TRUE(ok), ZERO(error) * //**************************************************** uint8_t queue_anhilate(Queue *qp) { 9be: cf 93 push r28 9c0: df 93 push r29 9c2: ec 01 movw r28, r24 sregsys = SREG; 9c4: 8f b7 in r24, 0x3f ; 63 9c6: 80 93 0a 01 sts 0x010A, r24 cli(); 9ca: f8 94 cli if (qp->message == 0) 9cc: 8d 81 ldd r24, Y+5 ; 0x05 9ce: 9e 81 ldd r25, Y+6 ; 0x06 9d0: 89 2b or r24, r25 9d2: 29 f4 brne .+10 ; 0x9de { SREG = sregsys; 9d4: 80 91 0a 01 lds r24, 0x010A 9d8: 8f bf out 0x3f, r24 ; 63 9da: 80 e0 ldi r24, 0x00 ; 0 9dc: 0c c0 rjmp .+24 ; 0x9f6 return 0; } //free memory and reset other values free ((void*) qp->message); 9de: 8d 81 ldd r24, Y+5 ; 0x05 9e0: 9e 81 ldd r25, Y+6 ; 0x06 9e2: 0e 94 45 06 call 0xc8a ; 0xc8a qp->message = 0; 9e6: 1e 82 std Y+6, r1 ; 0x06 9e8: 1d 82 std Y+5, r1 ; 0x05 qp->number = 0; 9ea: 1a 82 std Y+2, r1 ; 0x02 qp->queueDepth = 0; 9ec: 19 82 std Y+1, r1 ; 0x01 SREG = sregsys; 9ee: 80 91 0a 01 lds r24, 0x010A 9f2: 8f bf out 0x3f, r24 ; 63 9f4: 81 e0 ldi r24, 0x01 ; 1 return TRUE; } 9f6: df 91 pop r29 9f8: cf 91 pop r28 9fa: 08 95 ret 000009fc : //* 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) { 9fc: 0f 93 push r16 9fe: 1f 93 push r17 a00: cf 93 push r28 a02: df 93 push r29 a04: ec 01 movw r28, r24 a06: 16 2f mov r17, r22 a08: 04 2f mov r16, r20 sregsys = SREG; a0a: 8f b7 in r24, 0x3f ; 63 a0c: 80 93 0a 01 sts 0x010A, r24 cli(); a10: f8 94 cli if (MessageQueueDepth == 0 || item_size == 0 || MessageQueueDepth > MAXQUEUEDEPTH) a12: 66 23 and r22, r22 a14: b9 f0 breq .+46 ; 0xa44 a16: 44 23 and r20, r20 a18: a9 f0 breq .+42 ; 0xa44 a1a: 63 30 cpi r22, 0x03 ; 3 a1c: 98 f4 brcc .+38 ; 0xa44 { SREG = sregsys; return 0; } //allocate memory for queue dynamically qp->message = (unsigned char*) malloc (MessageQueueDepth*item_size); a1e: 46 9f mul r20, r22 a20: c0 01 movw r24, r0 a22: 11 24 eor r1, r1 a24: 0e 94 98 05 call 0xb30 ; 0xb30 a28: 9e 83 std Y+6, r25 ; 0x06 a2a: 8d 83 std Y+5, r24 ; 0x05 if (qp->message == 0 || (uint16_t) qp->message > SP) a2c: 8d 81 ldd r24, Y+5 ; 0x05 a2e: 9e 81 ldd r25, Y+6 ; 0x06 a30: 89 2b or r24, r25 a32: 39 f0 breq .+14 ; 0xa42 a34: 2d 81 ldd r18, Y+5 ; 0x05 a36: 3e 81 ldd r19, Y+6 ; 0x06 a38: 8d b7 in r24, 0x3d ; 61 a3a: 9e b7 in r25, 0x3e ; 62 a3c: 82 17 cp r24, r18 a3e: 93 07 cpc r25, r19 a40: 30 f4 brcc .+12 ; 0xa4e { qp->queueDepth = 0; a42: 19 82 std Y+1, r1 ; 0x01 SREG = sregsys; a44: 80 91 0a 01 lds r24, 0x010A a48: 8f bf out 0x3f, r24 ; 63 a4a: 80 e0 ldi r24, 0x00 ; 0 a4c: 0b c0 rjmp .+22 ; 0xa64 return 0; } qp->queueDepth = MessageQueueDepth*item_size; a4e: 01 9f mul r16, r17 a50: 80 2d mov r24, r0 a52: 11 24 eor r1, r1 a54: 89 83 std Y+1, r24 ; 0x01 qp->item_size = item_size; a56: 08 83 st Y, r16 qp->ptr = 0; a58: 1c 82 std Y+4, r1 ; 0x04 a5a: 1b 82 std Y+3, r1 ; 0x03 SREG = sregsys; a5c: 80 91 0a 01 lds r24, 0x010A a60: 8f bf out 0x3f, r24 ; 63 a62: 81 e0 ldi r24, 0x01 ; 1 return TRUE; } a64: df 91 pop r29 a66: cf 91 pop r28 a68: 1f 91 pop r17 a6a: 0f 91 pop r16 a6c: 08 95 ret 00000a6e
: #ifdef TASK_USE_SEMAPHORE #include "system/semaphore.c" #endif int main() { a6e: df 93 push r29 a70: cf 93 push r28 a72: cd b7 in r28, 0x3d ; 61 a74: de b7 in r29, 0x3e ; 62 a76: c5 54 subi r28, 0x45 ; 69 a78: d0 40 sbci r29, 0x00 ; 0 a7a: 0f b6 in r0, 0x3f ; 63 a7c: f8 94 cli a7e: de bf out 0x3e, r29 ; 62 a80: 0f be out 0x3f, r0 ; 63 a82: cd bf out 0x3d, r28 ; 61 static void kernel() { //Create an idle-task Task idletask; task_create(&idletask,idle,TaskPriorityLow); a84: ce 01 movw r24, r28 a86: 01 96 adiw r24, 0x01 ; 1 a88: 66 ed ldi r22, 0xD6 ; 214 a8a: 71 e0 ldi r23, 0x01 ; 1 a8c: 4f ef ldi r20, 0xFF ; 255 a8e: 0e 94 fc 00 call 0x1f8 ; 0x1f8 //enable watchdog wdt_enable(WDTO_2S); a92: 2f e0 ldi r18, 0x0F ; 15 a94: 88 e1 ldi r24, 0x18 ; 24 a96: 90 e0 ldi r25, 0x00 ; 0 a98: 0f b6 in r0, 0x3f ; 63 a9a: f8 94 cli a9c: a8 95 wdr a9e: 80 93 60 00 sts 0x0060, r24 aa2: 0f be out 0x3f, r0 ; 63 aa4: 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); aa8: 82 e8 ldi r24, 0x82 ; 130 aaa: 91 e0 ldi r25, 0x01 ; 1 aac: 63 e0 ldi r22, 0x03 ; 3 aae: 73 e0 ldi r23, 0x03 ; 3 ab0: 4f ef ldi r20, 0xFF ; 255 ab2: 0e 94 fc 00 call 0x1f8 ; 0x1f8 task_create(&display_hours_task, display_hours, TaskPriorityLow); ab6: 8e ec ldi r24, 0xCE ; 206 ab8: 91 e0 ldi r25, 0x01 ; 1 aba: 65 ee ldi r22, 0xE5 ; 229 abc: 72 e0 ldi r23, 0x02 ; 2 abe: 4f ef ldi r20, 0xFF ; 255 ac0: 0e 94 fc 00 call 0x1f8 ; 0x1f8 task_create(&time_calc_task, time_calc, TaskPriorityLow); ac4: 8d e3 ldi r24, 0x3D ; 61 ac6: 91 e0 ldi r25, 0x01 ; 1 ac8: 6a e3 ldi r22, 0x3A ; 58 aca: 74 e0 ldi r23, 0x04 ; 4 acc: 4f ef ldi r20, 0xFF ; 255 ace: 0e 94 fc 00 call 0x1f8 ; 0x1f8 //init Queues queue_init(&minutes_queue,1,1); ad2: 83 e1 ldi r24, 0x13 ; 19 ad4: 92 e0 ldi r25, 0x02 ; 2 ad6: 61 e0 ldi r22, 0x01 ; 1 ad8: 41 e0 ldi r20, 0x01 ; 1 ada: 0e 94 fe 04 call 0x9fc ; 0x9fc queue_init(&time_calc_queue,1,1); ade: 86 e3 ldi r24, 0x36 ; 54 ae0: 91 e0 ldi r25, 0x01 ; 1 ae2: 61 e0 ldi r22, 0x01 ; 1 ae4: 41 e0 ldi r20, 0x01 ; 1 ae6: 0e 94 fe 04 call 0x9fc ; 0x9fc queue_init(&hours_queue,2,1); aea: 87 ec ldi r24, 0xC7 ; 199 aec: 91 e0 ldi r25, 0x01 ; 1 aee: 62 e0 ldi r22, 0x02 ; 2 af0: 41 e0 ldi r20, 0x01 ; 1 af2: 0e 94 fe 04 call 0x9fc ; 0x9fc //set DDRB and DDRC as output DDRC=0xFF; af6: 8f ef ldi r24, 0xFF ; 255 af8: 87 b9 out 0x07, r24 ; 7 DDRD=0xFF; afa: 8a b9 out 0x0a, r24 ; 10 //setup timer2 TCCR2B = _BV(CS22) | _BV(CS21); // div by 256 afc: 86 e0 ldi r24, 0x06 ; 6 afe: 80 93 b1 00 sts 0x00B1, r24 // We will overflow 122 times a second, and call an interrupt // enable interrupt TIMSK2 = _BV(TOIE2); b02: 91 e0 ldi r25, 0x01 ; 1 b04: 90 93 70 00 sts 0x0070, r25 //Enable pullup resistor on PIN PB1 and PB2 PORTB = _BV(PB1) | _BV(PB2); b08: 85 b9 out 0x05, r24 ; 5 //These are the interrupts for the buttons PCICR = _BV(PCIE0); b0a: 90 93 68 00 sts 0x0068, r25 PCMSK0 = _BV(PCINT1) | _BV(PCINT2); b0e: 80 93 6b 00 sts 0x006B, r24 //init user specific stuff init_user_environment(); //start scheduler task_switch(); b12: 0e 94 b9 01 call 0x372 ; 0x372 b16: ff cf rjmp .-2 ; 0xb16 00000b18 <__udivmodqi4>: b18: 99 1b sub r25, r25 b1a: 79 e0 ldi r23, 0x09 ; 9 b1c: 04 c0 rjmp .+8 ; 0xb26 <__udivmodqi4_ep> 00000b1e <__udivmodqi4_loop>: b1e: 99 1f adc r25, r25 b20: 96 17 cp r25, r22 b22: 08 f0 brcs .+2 ; 0xb26 <__udivmodqi4_ep> b24: 96 1b sub r25, r22 00000b26 <__udivmodqi4_ep>: b26: 88 1f adc r24, r24 b28: 7a 95 dec r23 b2a: c9 f7 brne .-14 ; 0xb1e <__udivmodqi4_loop> b2c: 80 95 com r24 b2e: 08 95 ret 00000b30 : b30: cf 93 push r28 b32: df 93 push r29 b34: bc 01 movw r22, r24 b36: 82 30 cpi r24, 0x02 ; 2 b38: 91 05 cpc r25, r1 b3a: 10 f4 brcc .+4 ; 0xb40 b3c: 62 e0 ldi r22, 0x02 ; 2 b3e: 70 e0 ldi r23, 0x00 ; 0 b40: a0 91 1c 02 lds r26, 0x021C b44: b0 91 1d 02 lds r27, 0x021D b48: ed 01 movw r28, r26 b4a: e0 e0 ldi r30, 0x00 ; 0 b4c: f0 e0 ldi r31, 0x00 ; 0 b4e: 40 e0 ldi r20, 0x00 ; 0 b50: 50 e0 ldi r21, 0x00 ; 0 b52: 21 c0 rjmp .+66 ; 0xb96 b54: 88 81 ld r24, Y b56: 99 81 ldd r25, Y+1 ; 0x01 b58: 86 17 cp r24, r22 b5a: 97 07 cpc r25, r23 b5c: 69 f4 brne .+26 ; 0xb78 b5e: 8a 81 ldd r24, Y+2 ; 0x02 b60: 9b 81 ldd r25, Y+3 ; 0x03 b62: 30 97 sbiw r30, 0x00 ; 0 b64: 19 f0 breq .+6 ; 0xb6c b66: 93 83 std Z+3, r25 ; 0x03 b68: 82 83 std Z+2, r24 ; 0x02 b6a: 04 c0 rjmp .+8 ; 0xb74 b6c: 90 93 1d 02 sts 0x021D, r25 b70: 80 93 1c 02 sts 0x021C, r24 b74: fe 01 movw r30, r28 b76: 34 c0 rjmp .+104 ; 0xbe0 b78: 68 17 cp r22, r24 b7a: 79 07 cpc r23, r25 b7c: 38 f4 brcc .+14 ; 0xb8c b7e: 41 15 cp r20, r1 b80: 51 05 cpc r21, r1 b82: 19 f0 breq .+6 ; 0xb8a b84: 84 17 cp r24, r20 b86: 95 07 cpc r25, r21 b88: 08 f4 brcc .+2 ; 0xb8c b8a: ac 01 movw r20, r24 b8c: fe 01 movw r30, r28 b8e: 8a 81 ldd r24, Y+2 ; 0x02 b90: 9b 81 ldd r25, Y+3 ; 0x03 b92: 9c 01 movw r18, r24 b94: e9 01 movw r28, r18 b96: 20 97 sbiw r28, 0x00 ; 0 b98: e9 f6 brne .-70 ; 0xb54 b9a: 41 15 cp r20, r1 b9c: 51 05 cpc r21, r1 b9e: a9 f1 breq .+106 ; 0xc0a ba0: ca 01 movw r24, r20 ba2: 86 1b sub r24, r22 ba4: 97 0b sbc r25, r23 ba6: 04 97 sbiw r24, 0x04 ; 4 ba8: 08 f4 brcc .+2 ; 0xbac baa: ba 01 movw r22, r20 bac: e0 e0 ldi r30, 0x00 ; 0 bae: f0 e0 ldi r31, 0x00 ; 0 bb0: 2a c0 rjmp .+84 ; 0xc06 bb2: 8d 91 ld r24, X+ bb4: 9c 91 ld r25, X bb6: 11 97 sbiw r26, 0x01 ; 1 bb8: 84 17 cp r24, r20 bba: 95 07 cpc r25, r21 bbc: f9 f4 brne .+62 ; 0xbfc bbe: 64 17 cp r22, r20 bc0: 75 07 cpc r23, r21 bc2: 81 f4 brne .+32 ; 0xbe4 bc4: 12 96 adiw r26, 0x02 ; 2 bc6: 8d 91 ld r24, X+ bc8: 9c 91 ld r25, X bca: 13 97 sbiw r26, 0x03 ; 3 bcc: 30 97 sbiw r30, 0x00 ; 0 bce: 19 f0 breq .+6 ; 0xbd6 bd0: 93 83 std Z+3, r25 ; 0x03 bd2: 82 83 std Z+2, r24 ; 0x02 bd4: 04 c0 rjmp .+8 ; 0xbde bd6: 90 93 1d 02 sts 0x021D, r25 bda: 80 93 1c 02 sts 0x021C, r24 bde: fd 01 movw r30, r26 be0: 32 96 adiw r30, 0x02 ; 2 be2: 4f c0 rjmp .+158 ; 0xc82 be4: ca 01 movw r24, r20 be6: 86 1b sub r24, r22 be8: 97 0b sbc r25, r23 bea: fd 01 movw r30, r26 bec: e8 0f add r30, r24 bee: f9 1f adc r31, r25 bf0: 61 93 st Z+, r22 bf2: 71 93 st Z+, r23 bf4: 02 97 sbiw r24, 0x02 ; 2 bf6: 8d 93 st X+, r24 bf8: 9c 93 st X, r25 bfa: 43 c0 rjmp .+134 ; 0xc82 bfc: fd 01 movw r30, r26 bfe: 82 81 ldd r24, Z+2 ; 0x02 c00: 93 81 ldd r25, Z+3 ; 0x03 c02: 9c 01 movw r18, r24 c04: d9 01 movw r26, r18 c06: 10 97 sbiw r26, 0x00 ; 0 c08: a1 f6 brne .-88 ; 0xbb2 c0a: 80 91 1a 02 lds r24, 0x021A c0e: 90 91 1b 02 lds r25, 0x021B c12: 89 2b or r24, r25 c14: 41 f4 brne .+16 ; 0xc26 c16: 80 91 03 01 lds r24, 0x0103 c1a: 90 91 04 01 lds r25, 0x0104 c1e: 90 93 1b 02 sts 0x021B, r25 c22: 80 93 1a 02 sts 0x021A, r24 c26: 40 91 05 01 lds r20, 0x0105 c2a: 50 91 06 01 lds r21, 0x0106 c2e: 41 15 cp r20, r1 c30: 51 05 cpc r21, r1 c32: 41 f4 brne .+16 ; 0xc44 c34: 4d b7 in r20, 0x3d ; 61 c36: 5e b7 in r21, 0x3e ; 62 c38: 80 91 01 01 lds r24, 0x0101 c3c: 90 91 02 01 lds r25, 0x0102 c40: 48 1b sub r20, r24 c42: 59 0b sbc r21, r25 c44: 20 91 1a 02 lds r18, 0x021A c48: 30 91 1b 02 lds r19, 0x021B c4c: 24 17 cp r18, r20 c4e: 35 07 cpc r19, r21 c50: b0 f4 brcc .+44 ; 0xc7e c52: ca 01 movw r24, r20 c54: 82 1b sub r24, r18 c56: 93 0b sbc r25, r19 c58: 86 17 cp r24, r22 c5a: 97 07 cpc r25, r23 c5c: 80 f0 brcs .+32 ; 0xc7e c5e: ab 01 movw r20, r22 c60: 4e 5f subi r20, 0xFE ; 254 c62: 5f 4f sbci r21, 0xFF ; 255 c64: 84 17 cp r24, r20 c66: 95 07 cpc r25, r21 c68: 50 f0 brcs .+20 ; 0xc7e c6a: 42 0f add r20, r18 c6c: 53 1f adc r21, r19 c6e: 50 93 1b 02 sts 0x021B, r21 c72: 40 93 1a 02 sts 0x021A, r20 c76: f9 01 movw r30, r18 c78: 61 93 st Z+, r22 c7a: 71 93 st Z+, r23 c7c: 02 c0 rjmp .+4 ; 0xc82 c7e: e0 e0 ldi r30, 0x00 ; 0 c80: f0 e0 ldi r31, 0x00 ; 0 c82: cf 01 movw r24, r30 c84: df 91 pop r29 c86: cf 91 pop r28 c88: 08 95 ret 00000c8a : c8a: cf 93 push r28 c8c: df 93 push r29 c8e: 00 97 sbiw r24, 0x00 ; 0 c90: 09 f4 brne .+2 ; 0xc94 c92: 50 c0 rjmp .+160 ; 0xd34 c94: ec 01 movw r28, r24 c96: 22 97 sbiw r28, 0x02 ; 2 c98: 1b 82 std Y+3, r1 ; 0x03 c9a: 1a 82 std Y+2, r1 ; 0x02 c9c: a0 91 1c 02 lds r26, 0x021C ca0: b0 91 1d 02 lds r27, 0x021D ca4: 10 97 sbiw r26, 0x00 ; 0 ca6: 09 f1 breq .+66 ; 0xcea ca8: 40 e0 ldi r20, 0x00 ; 0 caa: 50 e0 ldi r21, 0x00 ; 0 cac: ac 17 cp r26, r28 cae: bd 07 cpc r27, r29 cb0: 08 f1 brcs .+66 ; 0xcf4 cb2: bb 83 std Y+3, r27 ; 0x03 cb4: aa 83 std Y+2, r26 ; 0x02 cb6: fe 01 movw r30, r28 cb8: 21 91 ld r18, Z+ cba: 31 91 ld r19, Z+ cbc: e2 0f add r30, r18 cbe: f3 1f adc r31, r19 cc0: ae 17 cp r26, r30 cc2: bf 07 cpc r27, r31 cc4: 79 f4 brne .+30 ; 0xce4 cc6: 8d 91 ld r24, X+ cc8: 9c 91 ld r25, X cca: 11 97 sbiw r26, 0x01 ; 1 ccc: 28 0f add r18, r24 cce: 39 1f adc r19, r25 cd0: 2e 5f subi r18, 0xFE ; 254 cd2: 3f 4f sbci r19, 0xFF ; 255 cd4: 39 83 std Y+1, r19 ; 0x01 cd6: 28 83 st Y, r18 cd8: 12 96 adiw r26, 0x02 ; 2 cda: 8d 91 ld r24, X+ cdc: 9c 91 ld r25, X cde: 13 97 sbiw r26, 0x03 ; 3 ce0: 9b 83 std Y+3, r25 ; 0x03 ce2: 8a 83 std Y+2, r24 ; 0x02 ce4: 41 15 cp r20, r1 ce6: 51 05 cpc r21, r1 ce8: 71 f4 brne .+28 ; 0xd06 cea: d0 93 1d 02 sts 0x021D, r29 cee: c0 93 1c 02 sts 0x021C, r28 cf2: 20 c0 rjmp .+64 ; 0xd34 cf4: 12 96 adiw r26, 0x02 ; 2 cf6: 8d 91 ld r24, X+ cf8: 9c 91 ld r25, X cfa: 13 97 sbiw r26, 0x03 ; 3 cfc: ad 01 movw r20, r26 cfe: 00 97 sbiw r24, 0x00 ; 0 d00: 11 f0 breq .+4 ; 0xd06 d02: dc 01 movw r26, r24 d04: d3 cf rjmp .-90 ; 0xcac d06: fa 01 movw r30, r20 d08: d3 83 std Z+3, r29 ; 0x03 d0a: c2 83 std Z+2, r28 ; 0x02 d0c: 21 91 ld r18, Z+ d0e: 31 91 ld r19, Z+ d10: e2 0f add r30, r18 d12: f3 1f adc r31, r19 d14: ce 17 cp r28, r30 d16: df 07 cpc r29, r31 d18: 69 f4 brne .+26 ; 0xd34 d1a: 88 81 ld r24, Y d1c: 99 81 ldd r25, Y+1 ; 0x01 d1e: 28 0f add r18, r24 d20: 39 1f adc r19, r25 d22: 2e 5f subi r18, 0xFE ; 254 d24: 3f 4f sbci r19, 0xFF ; 255 d26: fa 01 movw r30, r20 d28: 31 83 std Z+1, r19 ; 0x01 d2a: 20 83 st Z, r18 d2c: 8a 81 ldd r24, Y+2 ; 0x02 d2e: 9b 81 ldd r25, Y+3 ; 0x03 d30: 93 83 std Z+3, r25 ; 0x03 d32: 82 83 std Z+2, r24 ; 0x02 d34: df 91 pop r29 d36: cf 91 pop r28 d38: 08 95 ret 00000d3a <_exit>: d3a: f8 94 cli 00000d3c <__stop_program>: d3c: ff cf rjmp .-2 ; 0xd3c <__stop_program>