Bastelleien/Laminator
Bastelleien/Laminator
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
50d5098b13
Laminator/USBLaminator/USBLaminator/Debug/USBLaminator.lss

6383 lines
215 KiB
Plaintext
Raw Blame History

USBLaminator.elf: file format elf32-avr
Sections:
Idx Name Size VMA LMA File off Algn
0 .text 00001b88 00000000 00000000 00000094 2**1
CONTENTS, ALLOC, LOAD, READONLY, CODE
1 .data 00000142 00800060 00001b88 00001c1c 2**0
CONTENTS, ALLOC, LOAD, DATA
2 .bss 00000043 008001a2 008001a2 00001d5e 2**0
ALLOC
3 .stab 00003018 00000000 00000000 00001d60 2**2
CONTENTS, READONLY, DEBUGGING
4 .stabstr 00000855 00000000 00000000 00004d78 2**0
CONTENTS, READONLY, DEBUGGING
5 .comment 0000002f 00000000 00000000 000055cd 2**0
CONTENTS, READONLY
6 .debug_aranges 000000a8 00000000 00000000 000055fc 2**0
CONTENTS, READONLY, DEBUGGING
7 .debug_info 00008098 00000000 00000000 000056a4 2**0
CONTENTS, READONLY, DEBUGGING
8 .debug_abbrev 00000682 00000000 00000000 0000d73c 2**0
CONTENTS, READONLY, DEBUGGING
9 .debug_line 00000cc0 00000000 00000000 0000ddbe 2**0
CONTENTS, READONLY, DEBUGGING
10 .debug_frame 0000021c 00000000 00000000 0000ea80 2**2
CONTENTS, READONLY, DEBUGGING
11 .debug_str 00001a0c 00000000 00000000 0000ec9c 2**0
CONTENTS, READONLY, DEBUGGING
12 .debug_loc 00001e5f 00000000 00000000 000106a8 2**0
CONTENTS, READONLY, DEBUGGING
13 .debug_ranges 000000e0 00000000 00000000 00012507 2**0
CONTENTS, READONLY, DEBUGGING
Disassembly of section .text:
00000000 <__vectors>:
0: 0c 94 a8 00 jmp 0x150 ; 0x150 <__ctors_end>
4: 0c 94 e1 07 jmp 0xfc2 ; 0xfc2 <__vector_1>
8: 0c 94 d0 00 jmp 0x1a0 ; 0x1a0 <__bad_interrupt>
c: 0c 94 d0 00 jmp 0x1a0 ; 0x1a0 <__bad_interrupt>
10: 0c 94 d0 00 jmp 0x1a0 ; 0x1a0 <__bad_interrupt>
14: 0c 94 d0 00 jmp 0x1a0 ; 0x1a0 <__bad_interrupt>
18: 0c 94 5d 07 jmp 0xeba ; 0xeba <__vector_6>
1c: 0c 94 d0 00 jmp 0x1a0 ; 0x1a0 <__bad_interrupt>
20: 0c 94 d0 00 jmp 0x1a0 ; 0x1a0 <__bad_interrupt>
24: 0c 94 d0 00 jmp 0x1a0 ; 0x1a0 <__bad_interrupt>
28: 0c 94 d0 00 jmp 0x1a0 ; 0x1a0 <__bad_interrupt>
2c: 0c 94 ef 07 jmp 0xfde ; 0xfde <__vector_11>
30: 0c 94 d0 00 jmp 0x1a0 ; 0x1a0 <__bad_interrupt>
34: 0c 94 d0 00 jmp 0x1a0 ; 0x1a0 <__bad_interrupt>
38: 0c 94 d0 00 jmp 0x1a0 ; 0x1a0 <__bad_interrupt>
3c: 0c 94 d0 00 jmp 0x1a0 ; 0x1a0 <__bad_interrupt>
40: 0c 94 d0 00 jmp 0x1a0 ; 0x1a0 <__bad_interrupt>
44: 0c 94 d0 00 jmp 0x1a0 ; 0x1a0 <__bad_interrupt>
48: 0c 94 d0 00 jmp 0x1a0 ; 0x1a0 <__bad_interrupt>
4c: 0c 94 d0 00 jmp 0x1a0 ; 0x1a0 <__bad_interrupt>
50: 0c 94 d0 00 jmp 0x1a0 ; 0x1a0 <__bad_interrupt>
54: 00 40 sbci r16, 0x00 ; 0
56: 7a 10 cpse r7, r10
58: f3 5a subi r31, 0xA3 ; 163
5a: 00 a0 ldd r0, Z+32 ; 0x20
5c: 72 4e sbci r23, 0xE2 ; 226
5e: 18 09 sbc r17, r8
60: 00 10 cpse r0, r0
62: a5 d4 rcall .+2378 ; 0x9ae <__stack+0x54f>
64: e8 00 .word 0x00e8 ; ????
66: 00 e8 ldi r16, 0x80 ; 128
68: 76 48 sbci r23, 0x86 ; 134
6a: 17 00 .word 0x0017 ; ????
6c: 00 e4 ldi r16, 0x40 ; 64
6e: 0b 54 subi r16, 0x4B ; 75
70: 02 00 .word 0x0002 ; ????
72: 00 ca rjmp .-3072 ; 0xfffff474 <__eeprom_end+0xff7ef474>
74: 9a 3b cpi r25, 0xBA ; 186
76: 00 00 nop
78: 00 e1 ldi r16, 0x10 ; 16
7a: f5 05 cpc r31, r5
7c: 00 00 nop
7e: 80 96 adiw r24, 0x20 ; 32
80: 98 00 .word 0x0098 ; ????
82: 00 00 nop
84: 40 42 sbci r20, 0x20 ; 32
86: 0f 00 .word 0x000f ; ????
88: 00 00 nop
8a: a0 86 std Z+8, r10 ; 0x08
8c: 01 00 .word 0x0001 ; ????
8e: 00 00 nop
90: 10 27 eor r17, r16
92: 00 00 nop
94: 00 00 nop
96: e8 03 fmulsu r22, r16
98: 00 00 nop
9a: 00 00 nop
9c: 64 00 .word 0x0064 ; ????
9e: 00 00 nop
a0: 00 00 nop
a2: 0a 00 .word 0x000a ; ????
a4: 00 00 nop
a6: 00 00 nop
a8: 01 00 .word 0x0001 ; ????
aa: 00 00 nop
ac: 00 00 nop
ae: 2c 76 andi r18, 0x6C ; 108
b0: d8 88 ldd r13, Y+16 ; 0x10
b2: dc 67 ori r29, 0x7C ; 124
b4: 4f 08 sbc r4, r15
b6: 23 df rcall .-442 ; 0xfffffefe <__eeprom_end+0xff7efefe>
b8: c1 df rcall .-126 ; 0x3c <__zero_reg__+0x3b>
ba: ae 59 subi r26, 0x9E ; 158
bc: e1 b1 in r30, 0x01 ; 1
be: b7 96 adiw r30, 0x27 ; 39
c0: e5 e3 ldi r30, 0x35 ; 53
c2: e4 53 subi r30, 0x34 ; 52
c4: c6 3a cpi r28, 0xA6 ; 166
c6: e6 51 subi r30, 0x16 ; 22
c8: 99 76 andi r25, 0x69 ; 105
ca: 96 e8 ldi r25, 0x86 ; 134
cc: e6 c2 rjmp .+1484 ; 0x69a <__stack+0x23b>
ce: 84 26 eor r8, r20
d0: eb 89 ldd r30, Y+19 ; 0x13
d2: 8c 9b sbis 0x11, 4 ; 17
d4: 62 ed ldi r22, 0xD2 ; 210
d6: 40 7c andi r20, 0xC0 ; 192
d8: 6f fc .word 0xfc6f ; ????
da: ef bc out 0x2f, r14 ; 47
dc: 9c 9f mul r25, r28
de: 40 f2 brcs .-112 ; 0x70 <__SREG__+0x31>
e0: ba a5 ldd r27, Y+42 ; 0x2a
e2: 6f a5 ldd r22, Y+47 ; 0x2f
e4: f4 90 lpm r15, Z
e6: 05 5a subi r16, 0xA5 ; 165
e8: 2a f7 brpl .-54 ; 0xb4 <__SREG__+0x75>
ea: 5c 93 st X, r21
ec: 6b 6c ori r22, 0xCB ; 203
ee: f9 67 ori r31, 0x79 ; 121
f0: 6d c1 rjmp .+730 ; 0x3cc <main+0x12>
f2: 1b fc .word 0xfc1b ; ????
f4: e0 e4 ldi r30, 0x40 ; 64
f6: 0d 47 sbci r16, 0x7D ; 125
f8: fe f5 brtc .+126 ; 0x178 <__do_clear_bss+0x6>
fa: 20 e6 ldi r18, 0x60 ; 96
fc: b5 00 .word 0x00b5 ; ????
fe: d0 ed ldi r29, 0xD0 ; 208
100: 90 2e mov r9, r16
102: 03 00 .word 0x0003 ; ????
104: 94 35 cpi r25, 0x54 ; 84
106: 77 05 cpc r23, r7
108: 00 80 ld r0, Z
10a: 84 1e adc r8, r20
10c: 08 00 .word 0x0008 ; ????
10e: 00 20 and r0, r0
110: 4e 0a sbc r4, r30
112: 00 00 nop
114: 00 c8 rjmp .-4096 ; 0xfffff116 <__eeprom_end+0xff7ef116>
116: 0c 33 cpi r16, 0x3C ; 60
118: 33 33 cpi r19, 0x33 ; 51
11a: 33 0f add r19, r19
11c: 98 6e ori r25, 0xE8 ; 232
11e: 12 83 std Z+2, r17 ; 0x02
120: 11 41 sbci r17, 0x11 ; 17
122: ef 8d ldd r30, Y+31 ; 0x1f
124: 21 14 cp r2, r1
126: 89 3b cpi r24, 0xB9 ; 185
128: e6 55 subi r30, 0x56 ; 86
12a: 16 cf rjmp .-468 ; 0xffffff58 <__eeprom_end+0xff7eff58>
12c: fe e6 ldi r31, 0x6E ; 110
12e: db 18 sub r13, r11
130: d1 84 ldd r13, Z+9 ; 0x09
132: 4b 38 cpi r20, 0x8B ; 139
134: 1b f7 brvc .-58 ; 0xfc <__SREG__+0xbd>
136: 7c 1d adc r23, r12
138: 90 1d adc r25, r0
13a: a4 bb out 0x14, r26 ; 20
13c: e4 24 eor r14, r4
13e: 20 32 cpi r18, 0x20 ; 32
140: 84 72 andi r24, 0x24 ; 36
142: 5e 22 and r5, r30
144: 81 00 .word 0x0081 ; ????
146: c9 f1 breq .+114 ; 0x1ba <_Z5setupv+0x16>
148: 24 ec ldi r18, 0xC4 ; 196
14a: a1 e5 ldi r26, 0x51 ; 81
14c: 3d 27 eor r19, r29
0000014e <__ctors_start>:
14e: b7 08 sbc r11, r7
00000150 <__ctors_end>:
150: 11 24 eor r1, r1
152: 1f be out 0x3f, r1 ; 63
154: cf e5 ldi r28, 0x5F ; 95
156: d4 e0 ldi r29, 0x04 ; 4
158: de bf out 0x3e, r29 ; 62
15a: cd bf out 0x3d, r28 ; 61
0000015c <__do_copy_data>:
15c: 11 e0 ldi r17, 0x01 ; 1
15e: a0 e6 ldi r26, 0x60 ; 96
160: b0 e0 ldi r27, 0x00 ; 0
162: e8 e8 ldi r30, 0x88 ; 136
164: fb e1 ldi r31, 0x1B ; 27
166: 02 c0 rjmp .+4 ; 0x16c <__do_copy_data+0x10>
168: 05 90 lpm r0, Z+
16a: 0d 92 st X+, r0
16c: a2 3a cpi r26, 0xA2 ; 162
16e: b1 07 cpc r27, r17
170: d9 f7 brne .-10 ; 0x168 <__do_copy_data+0xc>
00000172 <__do_clear_bss>:
172: 21 e0 ldi r18, 0x01 ; 1
174: a2 ea ldi r26, 0xA2 ; 162
176: b1 e0 ldi r27, 0x01 ; 1
178: 01 c0 rjmp .+2 ; 0x17c <.do_clear_bss_start>
0000017a <.do_clear_bss_loop>:
17a: 1d 92 st X+, r1
0000017c <.do_clear_bss_start>:
17c: a5 3e cpi r26, 0xE5 ; 229
17e: b2 07 cpc r27, r18
180: e1 f7 brne .-8 ; 0x17a <.do_clear_bss_loop>
00000182 <__do_global_ctors>:
182: 11 e0 ldi r17, 0x01 ; 1
184: c0 e5 ldi r28, 0x50 ; 80
186: d1 e0 ldi r29, 0x01 ; 1
188: 04 c0 rjmp .+8 ; 0x192 <__do_global_ctors+0x10>
18a: 22 97 sbiw r28, 0x02 ; 2
18c: fe 01 movw r30, r28
18e: 0e 94 22 0b call 0x1644 ; 0x1644 <__tablejump__>
192: ce 34 cpi r28, 0x4E ; 78
194: d1 07 cpc r29, r17
196: c9 f7 brne .-14 ; 0x18a <__do_global_ctors+0x8>
198: 0e 94 dd 01 call 0x3ba ; 0x3ba <main>
19c: 0c 94 c2 0d jmp 0x1b84 ; 0x1b84 <_exit>
000001a0 <__bad_interrupt>:
1a0: 0c 94 00 00 jmp 0 ; 0x0 <__vectors>
000001a4 <_Z5setupv>:
usartclass r(l);
adcclass a;
buttonclass b(l);
void setup()
{
1a4: cf 93 push r28
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
1a6: c4 9a sbi 0x18, 4 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
1a8: bc 9a sbi 0x17, 4 ; 23
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
1aa: aa 98 cbi 0x15, 2 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
1ac: a2 9a sbi 0x14, 2 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
1ae: ab 98 cbi 0x15, 3 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
1b0: a3 9a sbi 0x14, 3 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
1b2: ac 98 cbi 0x15, 4 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
1b4: a4 9a sbi 0x14, 4 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
1b6: ad 98 cbi 0x15, 5 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
1b8: a5 9a sbi 0x14, 5 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
1ba: ae 98 cbi 0x15, 6 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
1bc: a6 9a sbi 0x14, 6 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
1be: af 98 cbi 0x15, 7 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
1c0: a7 9a sbi 0x14, 7 ; 20
1c2: e1 e9 ldi r30, 0x91 ; 145
1c4: f0 e0 ldi r31, 0x00 ; 0
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
1c6: 83 e2 ldi r24, 0x23 ; 35
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
1c8: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
1ca: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
1cc: 5d 9b sbis 0x0b, 5 ; 11
1ce: fe cf rjmp .-4 ; 0x1cc <_Z5setupv+0x28>
UDR = c;
1d0: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
1d2: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
1d4: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
1d6: 81 91 ld r24, Z+
1d8: 81 11 cpse r24, r1
1da: f6 cf rjmp .-20 ; 0x1c8 <_Z5setupv+0x24>
1dc: ee ec ldi r30, 0xCE ; 206
1de: f0 e0 ldi r31, 0x00 ; 0
1e0: 83 e2 ldi r24, 0x23 ; 35
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
1e2: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
1e4: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
1e6: 5d 9b sbis 0x0b, 5 ; 11
1e8: fe cf rjmp .-4 ; 0x1e6 <_Z5setupv+0x42>
UDR = c;
1ea: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
1ec: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
1ee: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
1f0: 81 91 ld r24, Z+
1f2: 81 11 cpse r24, r1
1f4: f6 cf rjmp .-20 ; 0x1e2 <_Z5setupv+0x3e>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
1f6: aa 98 cbi 0x15, 2 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
1f8: a2 9a sbi 0x14, 2 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
1fa: ab 98 cbi 0x15, 3 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
1fc: a3 9a sbi 0x14, 3 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
1fe: ac 98 cbi 0x15, 4 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
200: a4 9a sbi 0x14, 4 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
202: ad 98 cbi 0x15, 5 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
204: a5 9a sbi 0x14, 5 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
206: ae 98 cbi 0x15, 6 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
208: a6 9a sbi 0x14, 6 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
20a: af 98 cbi 0x15, 7 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
20c: a7 9a sbi 0x14, 7 ; 20
20e: 20 e0 ldi r18, 0x00 ; 0
210: 30 e0 ldi r19, 0x00 ; 0
return 0;
}
void test() {
off();
for (uint8_t i=0;i<6;i++) {
on((1<<i));
212: 41 e0 ldi r20, 0x01 ; 1
214: 50 e0 ldi r21, 0x00 ; 0
216: ca 01 movw r24, r20
218: 02 2e mov r0, r18
21a: 02 c0 rjmp .+4 ; 0x220 <_Z5setupv+0x7c>
21c: 88 0f add r24, r24
21e: 99 1f adc r25, r25
220: 0a 94 dec r0
222: e2 f7 brpl .-8 ; 0x21c <_Z5setupv+0x78>
if(ausg & OUT6) {
out6::make_low();
}
}
void on(uint8_t ausg = 255) {
if(ausg & OUT1) {
224: a8 2f mov r26, r24
226: a1 70 andi r26, 0x01 ; 1
228: 80 ff sbrs r24, 0
22a: 02 c0 rjmp .+4 ; 0x230 <_Z5setupv+0x8c>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
22c: aa 9a sbi 0x15, 2 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
22e: a2 9a sbi 0x14, 2 ; 20
out1::make_high();
}
if(ausg & OUT2) {
230: f8 2f mov r31, r24
232: f2 70 andi r31, 0x02 ; 2
234: 81 ff sbrs r24, 1
236: 02 c0 rjmp .+4 ; 0x23c <_Z5setupv+0x98>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
238: ab 9a sbi 0x15, 3 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
23a: a3 9a sbi 0x14, 3 ; 20
out2::make_high();
}
if(ausg & OUT3) {
23c: e8 2f mov r30, r24
23e: e4 70 andi r30, 0x04 ; 4
240: 82 ff sbrs r24, 2
242: 02 c0 rjmp .+4 ; 0x248 <_Z5setupv+0xa4>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
244: ac 9a sbi 0x15, 4 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
246: a4 9a sbi 0x14, 4 ; 20
out3::make_high();
}
if(ausg & OUT4) {
248: 78 2f mov r23, r24
24a: 78 70 andi r23, 0x08 ; 8
24c: 83 ff sbrs r24, 3
24e: 02 c0 rjmp .+4 ; 0x254 <_Z5setupv+0xb0>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
250: ad 9a sbi 0x15, 5 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
252: a5 9a sbi 0x14, 5 ; 20
out4::make_high();
}
if(ausg & OUT5) {
254: 68 2f mov r22, r24
256: 60 71 andi r22, 0x10 ; 16
258: 84 ff sbrs r24, 4
25a: 02 c0 rjmp .+4 ; 0x260 <_Z5setupv+0xbc>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
25c: ae 9a sbi 0x15, 6 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
25e: a6 9a sbi 0x14, 6 ; 20
out5::make_high();
}
if(ausg & OUT6) {
260: 98 2f mov r25, r24
262: 90 72 andi r25, 0x20 ; 32
264: 85 ff sbrs r24, 5
266: 02 c0 rjmp .+4 ; 0x26c <_Z5setupv+0xc8>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
268: af 9a sbi 0x15, 7 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
26a: a7 9a sbi 0x14, 7 ; 20
#else
//round up by default
__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
#endif
__builtin_avr_delay_cycles(__ticks_dc);
26c: 8f ef ldi r24, 0xFF ; 255
26e: b1 ee ldi r27, 0xE1 ; 225
270: c4 e0 ldi r28, 0x04 ; 4
272: 81 50 subi r24, 0x01 ; 1
274: b0 40 sbci r27, 0x00 ; 0
276: c0 40 sbci r28, 0x00 ; 0
278: e1 f7 brne .-8 ; 0x272 <_Z5setupv+0xce>
27a: 00 c0 rjmp .+0 ; 0x27c <_Z5setupv+0xd8>
27c: 00 00 nop
public:
SSR() {
init();
}
void off(uint8_t ausg = 255) {
if(ausg & OUT1) {
27e: aa 23 and r26, r26
280: 11 f0 breq .+4 ; 0x286 <_Z5setupv+0xe2>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
282: aa 98 cbi 0x15, 2 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
284: a2 9a sbi 0x14, 2 ; 20
out1::make_low();
}
if(ausg & OUT2) {
286: ff 23 and r31, r31
288: 11 f0 breq .+4 ; 0x28e <_Z5setupv+0xea>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
28a: ab 98 cbi 0x15, 3 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
28c: a3 9a sbi 0x14, 3 ; 20
out2::make_low();
}
if(ausg & OUT3) {
28e: ee 23 and r30, r30
290: 11 f0 breq .+4 ; 0x296 <_Z5setupv+0xf2>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
292: ac 98 cbi 0x15, 4 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
294: a4 9a sbi 0x14, 4 ; 20
out3::make_low();
}
if(ausg & OUT4) {
296: 77 23 and r23, r23
298: 11 f0 breq .+4 ; 0x29e <_Z5setupv+0xfa>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
29a: ad 98 cbi 0x15, 5 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
29c: a5 9a sbi 0x14, 5 ; 20
out4::make_low();
}
if(ausg & OUT5) {
29e: 66 23 and r22, r22
2a0: 11 f0 breq .+4 ; 0x2a6 <_Z5setupv+0x102>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
2a2: ae 98 cbi 0x15, 6 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
2a4: a6 9a sbi 0x14, 6 ; 20
out5::make_low();
}
if(ausg & OUT6) {
2a6: 99 23 and r25, r25
2a8: 11 f0 breq .+4 ; 0x2ae <_Z5setupv+0x10a>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
2aa: af 98 cbi 0x15, 7 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
2ac: a7 9a sbi 0x14, 7 ; 20
2ae: 2f 5f subi r18, 0xFF ; 255
2b0: 3f 4f sbci r19, 0xFF ; 255
}
return 0;
}
void test() {
off();
for (uint8_t i=0;i<6;i++) {
2b2: 26 30 cpi r18, 0x06 ; 6
2b4: 31 05 cpc r19, r1
2b6: 09 f0 breq .+2 ; 0x2ba <_Z5setupv+0x116>
2b8: ae cf rjmp .-164 ; 0x216 <_Z5setupv+0x72>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
2ba: aa 98 cbi 0x15, 2 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
2bc: a2 9a sbi 0x14, 2 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
2be: ab 98 cbi 0x15, 3 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
2c0: a3 9a sbi 0x14, 3 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
2c2: ac 98 cbi 0x15, 4 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
2c4: a4 9a sbi 0x14, 4 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
2c6: ad 98 cbi 0x15, 5 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
2c8: a5 9a sbi 0x14, 5 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
2ca: ae 98 cbi 0x15, 6 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
2cc: a6 9a sbi 0x14, 6 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
2ce: af 98 cbi 0x15, 7 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
2d0: a7 9a sbi 0x14, 7 ; 20
2d2: ed ed ldi r30, 0xDD ; 221
2d4: f0 e0 ldi r31, 0x00 ; 0
2d6: 83 e2 ldi r24, 0x23 ; 35
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
2d8: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
2da: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
2dc: 5d 9b sbis 0x0b, 5 ; 11
2de: fe cf rjmp .-4 ; 0x2dc <_Z5setupv+0x138>
UDR = c;
2e0: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
2e2: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
2e4: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
2e6: 81 91 ld r24, Z+
2e8: 81 11 cpse r24, r1
2ea: f6 cf rjmp .-20 ; 0x2d8 <_Z5setupv+0x134>
// Timer Period: 0,1 s
// Timer1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: On
// Compare B Match Interrupt: Off
TCCR1A = 0;
2ec: 1f bc out 0x2f, r1 ; 47
TCCR1B |= (1<<WGM12) | (1<<CS11) | (1<<CS10);
2ee: 8e b5 in r24, 0x2e ; 46
2f0: 8b 60 ori r24, 0x0B ; 11
2f2: 8e bd out 0x2e, r24 ; 46
TCNT1H = 0;
2f4: 1d bc out 0x2d, r1 ; 45
TCNT1L = 0;
2f6: 1c bc out 0x2c, r1 ; 44
ICR1H = 0;
2f8: 17 bc out 0x27, r1 ; 39
ICR1L = 0;
2fa: 16 bc out 0x26, r1 ; 38
OCR1AH = 0x61;
2fc: 81 e6 ldi r24, 0x61 ; 97
2fe: 8b bd out 0x2b, r24 ; 43
OCR1AL = 0xA8;
300: 88 ea ldi r24, 0xA8 ; 168
302: 8a bd out 0x2a, r24 ; 42
OCR1BH = 0;
304: 19 bc out 0x29, r1 ; 41
OCR1BL = 0;
306: 18 bc out 0x28, r1 ; 40
// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK |= (1<<OCIE1A);
308: 89 b7 in r24, 0x39 ; 57
30a: 80 61 ori r24, 0x10 ; 16
30c: 89 bf out 0x39, r24 ; 57
sei();
30e: 78 94 sei
310: ec ee ldi r30, 0xEC ; 236
312: f0 e0 ldi r31, 0x00 ; 0
314: 83 e2 ldi r24, 0x23 ; 35
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
316: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
318: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
31a: 5d 9b sbis 0x0b, 5 ; 11
31c: fe cf rjmp .-4 ; 0x31a <_Z5setupv+0x176>
UDR = c;
31e: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
320: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
322: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
324: 81 91 ld r24, Z+
326: 81 11 cpse r24, r1
328: f6 cf rjmp .-20 ; 0x316 <_Z5setupv+0x172>
32a: 2f c0 rjmp .+94 ; 0x38a <_Z5setupv+0x1e6>
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
32c: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
32e: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
330: 5d 9b sbis 0x0b, 5 ; 11
332: fe cf rjmp .-4 ; 0x330 <_Z5setupv+0x18c>
UDR = c;
334: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
336: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
338: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
33a: 81 91 ld r24, Z+
33c: 81 11 cpse r24, r1
33e: f6 cf rjmp .-20 ; 0x32c <_Z5setupv+0x188>
340: 2c c0 rjmp .+88 ; 0x39a <_Z5setupv+0x1f6>
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
342: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
344: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
346: 5d 9b sbis 0x0b, 5 ; 11
348: fe cf rjmp .-4 ; 0x346 <_Z5setupv+0x1a2>
UDR = c;
34a: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
34c: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
34e: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
350: 81 91 ld r24, Z+
352: 81 11 cpse r24, r1
354: f6 cf rjmp .-20 ; 0x342 <_Z5setupv+0x19e>
Button(ledclass l) {
init();
this->led = l;
}
void setup_intr() {
GICR |= (1<<INT0);
356: 8b b7 in r24, 0x3b ; 59
358: 80 64 ori r24, 0x40 ; 64
35a: 8b bf out 0x3b, r24 ; 59
MCUCR = (1<<ISC01);
35c: 82 e0 ldi r24, 0x02 ; 2
35e: 85 bf out 0x35, r24 ; 53
//MCUCSR = 0;
GIFR = (1<<INTF0);
360: 80 e4 ldi r24, 0x40 ; 64
362: 8a bf out 0x3a, r24 ; 58
sei();
364: 78 94 sei
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
366: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
368: bb 9a sbi 0x17, 3 ; 23
36a: e2 e0 ldi r30, 0x02 ; 2
36c: f1 e0 ldi r31, 0x01 ; 1
36e: 83 e2 ldi r24, 0x23 ; 35
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
370: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
372: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
374: 5d 9b sbis 0x0b, 5 ; 11
376: fe cf rjmp .-4 ; 0x374 <_Z5setupv+0x1d0>
UDR = c;
378: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
37a: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
37c: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
37e: 81 91 ld r24, Z+
380: 81 11 cpse r24, r1
382: f6 cf rjmp .-20 ; 0x370 <_Z5setupv+0x1cc>
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
384: c2 9a sbi 0x18, 2 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
386: ba 9a sbi 0x17, 2 ; 23
388: 16 c0 rjmp .+44 ; 0x3b6 <_Z5setupv+0x212>
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
38a: c4 98 cbi 0x18, 4 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
38c: bc 9a sbi 0x17, 4 ; 23
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
38e: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
390: bb 9a sbi 0x17, 3 ; 23
392: ef e3 ldi r30, 0x3F ; 63
394: f1 e0 ldi r31, 0x01 ; 1
396: 83 e2 ldi r24, 0x23 ; 35
398: c9 cf rjmp .-110 ; 0x32c <_Z5setupv+0x188>
public:
Adc() {
init();
}
void on() {
ADCSRA |= (1<<ADEN);
39a: 37 9a sbi 0x06, 7 ; 6
39c: 2f ef ldi r18, 0xFF ; 255
39e: 81 ee ldi r24, 0xE1 ; 225
3a0: 94 e0 ldi r25, 0x04 ; 4
3a2: 21 50 subi r18, 0x01 ; 1
3a4: 80 40 sbci r24, 0x00 ; 0
3a6: 90 40 sbci r25, 0x00 ; 0
3a8: e1 f7 brne .-8 ; 0x3a2 <_Z5setupv+0x1fe>
3aa: 00 c0 rjmp .+0 ; 0x3ac <_Z5setupv+0x208>
3ac: 00 00 nop
3ae: ec e4 ldi r30, 0x4C ; 76
3b0: f1 e0 ldi r31, 0x01 ; 1
3b2: 83 e2 ldi r24, 0x23 ; 35
3b4: c6 cf rjmp .-116 ; 0x342 <_Z5setupv+0x19e>
r.send("# Setup Button\n");
b.setup_intr();
l.off(l.YELLOW);
r.send("#### End Bootup ###########################################\n");
l.on(l.GREEN);
}
3b6: cf 91 pop r28
3b8: 08 95 ret
000003ba <main>:
int main(void)
{
3ba: cf 93 push r28
3bc: df 93 push r29
3be: cd b7 in r28, 0x3d ; 61
3c0: de b7 in r29, 0x3e ; 62
3c2: c3 5a subi r28, 0xA3 ; 163
3c4: d1 09 sbc r29, r1
3c6: 0f b6 in r0, 0x3f ; 63
3c8: f8 94 cli
3ca: de bf out 0x3e, r29 ; 62
3cc: 0f be out 0x3f, r0 ; 63
3ce: cd bf out 0x3d, r28 ; 61
setup();
3d0: 0e 94 d2 00 call 0x1a4 ; 0x1a4 <_Z5setupv>
int16_t target_temp = 20;
int8_t target_motor = 20;
float pwm_value = 0;
uint16_t v0a[20] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
3d4: 88 e2 ldi r24, 0x28 ; 40
3d6: fe 01 movw r30, r28
3d8: b9 96 adiw r30, 0x29 ; 41
3da: df 01 movw r26, r30
3dc: 28 2f mov r18, r24
3de: 1d 92 st X+, r1
3e0: 2a 95 dec r18
3e2: e9 f7 brne .-6 ; 0x3de <main+0x24>
uint16_t v1a[20] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
3e4: fe 01 movw r30, r28
3e6: 31 96 adiw r30, 0x01 ; 1
3e8: df 01 movw r26, r30
3ea: 1d 92 st X+, r1
3ec: 8a 95 dec r24
3ee: e9 f7 brne .-6 ; 0x3ea <main+0x30>
uint8_t p = 0;
3f0: c9 56 subi r28, 0x69 ; 105
3f2: df 4f sbci r29, 0xFF ; 255
3f4: 18 82 st Y, r1
3f6: c7 59 subi r28, 0x97 ; 151
3f8: d0 40 sbci r29, 0x00 ; 0
int main(void)
{
setup();
int16_t target_temp = 20;
int8_t target_motor = 20;
3fa: b4 e1 ldi r27, 0x14 ; 20
3fc: ca 56 subi r28, 0x6A ; 106
3fe: df 4f sbci r29, 0xFF ; 255
400: b8 83 st Y, r27
402: c6 59 subi r28, 0x96 ; 150
404: d0 40 sbci r29, 0x00 ; 0
}
int main(void)
{
setup();
int16_t target_temp = 20;
406: e4 e1 ldi r30, 0x14 ; 20
408: f0 e0 ldi r31, 0x00 ; 0
40a: cc 56 subi r28, 0x6C ; 108
40c: df 4f sbci r29, 0xFF ; 255
40e: f9 83 std Y+1, r31 ; 0x01
410: e8 83 st Y, r30
412: c4 59 subi r28, 0x94 ; 148
414: d0 40 sbci r29, 0x00 ; 0
uint16_t v0a[20] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint16_t v1a[20] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint8_t p = 0;
while(1)
{
v0a[p] = a.get(0);
416: 9e 01 movw r18, r28
418: 2f 5f subi r18, 0xFF ; 255
41a: 3f 4f sbci r19, 0xFF ; 255
41c: c8 57 subi r28, 0x78 ; 120
41e: df 4f sbci r29, 0xFF ; 255
420: 39 83 std Y+1, r19 ; 0x01
422: 28 83 st Y, r18
424: c8 58 subi r28, 0x88 ; 136
426: d0 40 sbci r29, 0x00 ; 0
428: ce 55 subi r28, 0x5E ; 94
42a: df 4f sbci r29, 0xFF ; 255
42c: 28 83 st Y, r18
42e: c2 5a subi r28, 0xA2 ; 162
430: d0 40 sbci r29, 0x00 ; 0
432: cd 55 subi r28, 0x5D ; 93
434: df 4f sbci r29, 0xFF ; 255
436: 38 83 st Y, r19
438: c3 5a subi r28, 0xA3 ; 163
43a: d0 40 sbci r29, 0x00 ; 0
l.off(l.YELLOW);
r.send("#### End Bootup ###########################################\n");
l.on(l.GREEN);
}
int main(void)
43c: 0f 2e mov r0, r31
43e: f9 e2 ldi r31, 0x29 ; 41
440: af 2e mov r10, r31
442: b1 2c mov r11, r1
444: f0 2d mov r31, r0
446: ac 0e add r10, r28
448: bd 1e adc r11, r29
44a: 38 e2 ldi r19, 0x28 ; 40
44c: a3 0e add r10, r19
44e: b1 1c adc r11, r1
uint16_t v0a[20] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint16_t v1a[20] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint8_t p = 0;
while(1)
{
v0a[p] = a.get(0);
450: c9 56 subi r28, 0x69 ; 105
452: df 4f sbci r29, 0xFF ; 255
454: 88 81 ld r24, Y
456: c7 59 subi r28, 0x97 ; 151
458: d0 40 sbci r29, 0x00 ; 0
45a: 48 2f mov r20, r24
45c: 50 e0 ldi r21, 0x00 ; 0
_delay_ms(100);
}
uint16_t get(uint8_t pin) {
ADMUX &= ~((1<<MUX2) | (1<<MUX1) | (1<<MUX0));
45e: 87 b1 in r24, 0x07 ; 7
460: 88 7f andi r24, 0xF8 ; 248
462: 87 b9 out 0x07, r24 ; 7
ADMUX |= pin;
464: 87 b1 in r24, 0x07 ; 7
466: 87 b9 out 0x07, r24 ; 7
#else
//round up by default
__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
#endif
__builtin_avr_delay_cycles(__ticks_dc);
468: 95 e3 ldi r25, 0x35 ; 53
46a: 9a 95 dec r25
46c: f1 f7 brne .-4 ; 0x46a <__stack+0xb>
46e: 00 00 nop
//ADMUX = 0;
_delay_us(10);
ADCSRA |= (1<<ADSC);
470: 36 9a sbi 0x06, 6 ; 6
loop_until_bit_is_set(ADCSRA, ADIF);
472: 34 9b sbis 0x06, 4 ; 6
474: fe cf rjmp .-4 ; 0x472 <__stack+0x13>
//ADCSRA |= (1<<ADIF);
return ADCW;
476: 84 b1 in r24, 0x04 ; 4
478: 95 b1 in r25, 0x05 ; 5
47a: fa 01 movw r30, r20
47c: ee 0f add r30, r30
47e: ff 1f adc r31, r31
480: a1 e0 ldi r26, 0x01 ; 1
482: b0 e0 ldi r27, 0x00 ; 0
484: ac 0f add r26, r28
486: bd 1f adc r27, r29
488: ea 0f add r30, r26
48a: fb 1f adc r31, r27
48c: 91 a7 std Z+41, r25 ; 0x29
48e: 80 a7 std Z+40, r24 ; 0x28
void on() {
ADCSRA |= (1<<ADEN);
_delay_ms(100);
}
uint16_t get(uint8_t pin) {
ADMUX &= ~((1<<MUX2) | (1<<MUX1) | (1<<MUX0));
490: 87 b1 in r24, 0x07 ; 7
492: 88 7f andi r24, 0xF8 ; 248
494: 87 b9 out 0x07, r24 ; 7
ADMUX |= pin;
496: 38 9a sbi 0x07, 0 ; 7
498: b5 e3 ldi r27, 0x35 ; 53
49a: ba 95 dec r27
49c: f1 f7 brne .-4 ; 0x49a <__stack+0x3b>
49e: 00 00 nop
//ADMUX = 0;
_delay_us(10);
ADCSRA |= (1<<ADSC);
4a0: 36 9a sbi 0x06, 6 ; 6
loop_until_bit_is_set(ADCSRA, ADIF);
4a2: 34 9b sbis 0x06, 4 ; 6
4a4: fe cf rjmp .-4 ; 0x4a2 <__stack+0x43>
//ADCSRA |= (1<<ADIF);
return ADCW;
4a6: 84 b1 in r24, 0x04 ; 4
4a8: 95 b1 in r25, 0x05 ; 5
v1a[p] = a.get(1);
4aa: fa 01 movw r30, r20
4ac: ee 0f add r30, r30
4ae: ff 1f adc r31, r31
4b0: 21 e0 ldi r18, 0x01 ; 1
4b2: 30 e0 ldi r19, 0x00 ; 0
4b4: 2c 0f add r18, r28
4b6: 3d 1f adc r19, r29
4b8: e2 0f add r30, r18
4ba: f3 1f adc r31, r19
4bc: 91 83 std Z+1, r25 ; 0x01
4be: 80 83 st Z, r24
4c0: fe 01 movw r30, r28
4c2: b9 96 adiw r30, 0x29 ; 41
4c4: ce 55 subi r28, 0x5E ; 94
4c6: df 4f sbci r29, 0xFF ; 255
4c8: a8 81 ld r26, Y
4ca: c2 5a subi r28, 0xA2 ; 162
4cc: d0 40 sbci r29, 0x00 ; 0
4ce: cd 55 subi r28, 0x5D ; 93
4d0: df 4f sbci r29, 0xFF ; 255
4d2: b8 81 ld r27, Y
4d4: c3 5a subi r28, 0xA3 ; 163
4d6: d0 40 sbci r29, 0x00 ; 0
uint16_t v0s = 0;
uint16_t v1s = 0;
4d8: 00 e0 ldi r16, 0x00 ; 0
4da: 10 e0 ldi r17, 0x00 ; 0
uint8_t p = 0;
while(1)
{
v0a[p] = a.get(0);
v1a[p] = a.get(1);
uint16_t v0s = 0;
4dc: 20 e0 ldi r18, 0x00 ; 0
4de: 30 e0 ldi r19, 0x00 ; 0
uint16_t v1s = 0;
for (uint8_t i = 0; i < 20; i++)
{
v0s += v0a[i];
4e0: 81 91 ld r24, Z+
4e2: 91 91 ld r25, Z+
4e4: 28 0f add r18, r24
4e6: 39 1f adc r19, r25
v1s += v1a[i];
4e8: 8d 91 ld r24, X+
4ea: 9d 91 ld r25, X+
4ec: 08 0f add r16, r24
4ee: 19 1f adc r17, r25
{
v0a[p] = a.get(0);
v1a[p] = a.get(1);
uint16_t v0s = 0;
uint16_t v1s = 0;
for (uint8_t i = 0; i < 20; i++)
4f0: ea 15 cp r30, r10
4f2: fb 05 cpc r31, r11
4f4: a9 f7 brne .-22 ; 0x4e0 <__stack+0x81>
{
v0s += v0a[i];
v1s += v1a[i];
}
uint16_t v0 = v0s/20;
4f6: ad ec ldi r26, 0xCD ; 205
4f8: bc ec ldi r27, 0xCC ; 204
4fa: 0e 94 00 0b call 0x1600 ; 0x1600 <__umulhisi3>
4fe: 7c 01 movw r14, r24
500: f6 94 lsr r15
502: e7 94 ror r14
504: f6 94 lsr r15
506: e7 94 ror r14
508: f6 94 lsr r15
50a: e7 94 ror r14
50c: f6 94 lsr r15
50e: e7 94 ror r14
uint16_t v1 = v1s/20;
510: 98 01 movw r18, r16
512: 0e 94 00 0b call 0x1600 ; 0x1600 <__umulhisi3>
516: 6c 01 movw r12, r24
518: d6 94 lsr r13
51a: c7 94 ror r12
51c: d6 94 lsr r13
51e: c7 94 ror r12
520: d6 94 lsr r13
522: c7 94 ror r12
524: d6 94 lsr r13
526: c7 94 ror r12
p = (p + 1) % 20;
528: ca 01 movw r24, r20
52a: 01 96 adiw r24, 0x01 ; 1
52c: 64 e1 ldi r22, 0x14 ; 20
52e: 70 e0 ldi r23, 0x00 ; 0
530: 0e 94 ec 0a call 0x15d8 ; 0x15d8 <__divmodhi4>
534: c9 56 subi r28, 0x69 ; 105
536: df 4f sbci r29, 0xFF ; 255
538: 88 83 st Y, r24
53a: c7 59 subi r28, 0x97 ; 151
53c: d0 40 sbci r29, 0x00 ; 0
if(v0 > 1000 || v1 > 1000 || v0 < 5 || v1 < 5) {
53e: 39 ee ldi r19, 0xE9 ; 233
540: e3 16 cp r14, r19
542: 33 e0 ldi r19, 0x03 ; 3
544: f3 06 cpc r15, r19
546: 68 f4 brcc .+26 ; 0x562 <__stack+0x103>
548: 89 ee ldi r24, 0xE9 ; 233
54a: c8 16 cp r12, r24
54c: 83 e0 ldi r24, 0x03 ; 3
54e: d8 06 cpc r13, r24
550: 40 f4 brcc .+16 ; 0x562 <__stack+0x103>
552: 95 e0 ldi r25, 0x05 ; 5
554: e9 16 cp r14, r25
556: f1 04 cpc r15, r1
558: 20 f0 brcs .+8 ; 0x562 <__stack+0x103>
55a: a5 e0 ldi r26, 0x05 ; 5
55c: ca 16 cp r12, r26
55e: d1 04 cpc r13, r1
560: 68 f4 brcc .+26 ; 0x57c <__stack+0x11d>
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
562: c4 9a sbi 0x18, 4 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
564: bc 9a sbi 0x17, 4 ; 23
}
}
//out1::toggle();
}
void stop() {
pwm[0] = 0; pwm[1] = 0; pwm[2] = 0; pwm[3] = 0; pwm[4] = 0; pwm[5] = 0; pwm[6] = 0;
566: 10 92 e0 01 sts 0x01E0, r1
56a: 10 92 e1 01 sts 0x01E1, r1
56e: 10 92 e2 01 sts 0x01E2, r1
572: 10 92 e3 01 sts 0x01E3, r1
576: 10 92 e4 01 sts 0x01E4, r1
57a: ff cf rjmp .-2 ; 0x57a <__stack+0x11b>
}
float convert(uint16_t v, uint8_t pin) {
float c1 = this->table[pin][0];
57c: e3 ea ldi r30, 0xA3 ; 163
57e: f1 e0 ldi r31, 0x01 ; 1
580: 60 81 ld r22, Z
582: 71 81 ldd r23, Z+1 ; 0x01
584: 80 e0 ldi r24, 0x00 ; 0
586: 90 e0 ldi r25, 0x00 ; 0
588: 0e 94 d3 09 call 0x13a6 ; 0x13a6 <__floatunsisf>
58c: 36 2e mov r3, r22
58e: 27 2e mov r2, r23
590: c6 57 subi r28, 0x76 ; 118
592: df 4f sbci r29, 0xFF ; 255
594: 88 83 st Y, r24
596: ca 58 subi r28, 0x8A ; 138
598: d0 40 sbci r29, 0x00 ; 0
59a: c5 57 subi r28, 0x75 ; 117
59c: df 4f sbci r29, 0xFF ; 255
59e: 98 83 st Y, r25
5a0: cb 58 subi r28, 0x8B ; 139
5a2: d0 40 sbci r29, 0x00 ; 0
float v1 = this->table[pin][1];
5a4: a5 ea ldi r26, 0xA5 ; 165
5a6: b1 e0 ldi r27, 0x01 ; 1
5a8: 6d 91 ld r22, X+
5aa: 7c 91 ld r23, X
5ac: 80 e0 ldi r24, 0x00 ; 0
5ae: 90 e0 ldi r25, 0x00 ; 0
5b0: 0e 94 d3 09 call 0x13a6 ; 0x13a6 <__floatunsisf>
5b4: 06 2f mov r16, r22
5b6: 17 2f mov r17, r23
5b8: 98 2e mov r9, r24
5ba: 89 2e mov r8, r25
float c2 = this->table[pin][2];
5bc: e7 ea ldi r30, 0xA7 ; 167
5be: f1 e0 ldi r31, 0x01 ; 1
5c0: 60 81 ld r22, Z
5c2: 71 81 ldd r23, Z+1 ; 0x01
5c4: 80 e0 ldi r24, 0x00 ; 0
5c6: 90 e0 ldi r25, 0x00 ; 0
5c8: 0e 94 d3 09 call 0x13a6 ; 0x13a6 <__floatunsisf>
5cc: 9b 01 movw r18, r22
5ce: ac 01 movw r20, r24
float v2 = this->table[pin][3];
float m = ((c1 - c2) / (v1 - v2));
5d0: c6 57 subi r28, 0x76 ; 118
5d2: df 4f sbci r29, 0xFF ; 255
5d4: f8 81 ld r31, Y
5d6: ca 58 subi r28, 0x8A ; 138
5d8: d0 40 sbci r29, 0x00 ; 0
5da: c5 57 subi r28, 0x75 ; 117
5dc: df 4f sbci r29, 0xFF ; 255
5de: e8 81 ld r30, Y
5e0: cb 58 subi r28, 0x8B ; 139
5e2: d0 40 sbci r29, 0x00 ; 0
5e4: 63 2d mov r22, r3
5e6: 72 2d mov r23, r2
5e8: 8f 2f mov r24, r31
5ea: 9e 2f mov r25, r30
5ec: 0e 94 d6 08 call 0x11ac ; 0x11ac <__subsf3>
5f0: 2b 01 movw r4, r22
5f2: 3c 01 movw r6, r24
float convert(uint16_t v, uint8_t pin) {
float c1 = this->table[pin][0];
float v1 = this->table[pin][1];
float c2 = this->table[pin][2];
float v2 = this->table[pin][3];
5f4: 60 91 a9 01 lds r22, 0x01A9
5f8: 70 91 aa 01 lds r23, 0x01AA
5fc: 80 e0 ldi r24, 0x00 ; 0
5fe: 90 e0 ldi r25, 0x00 ; 0
600: 0e 94 d3 09 call 0x13a6 ; 0x13a6 <__floatunsisf>
604: 9b 01 movw r18, r22
606: ac 01 movw r20, r24
float m = ((c1 - c2) / (v1 - v2));
608: 60 2f mov r22, r16
60a: 71 2f mov r23, r17
60c: 89 2d mov r24, r9
60e: 98 2d mov r25, r8
610: 0e 94 d6 08 call 0x11ac ; 0x11ac <__subsf3>
614: 9b 01 movw r18, r22
616: ac 01 movw r20, r24
618: c3 01 movw r24, r6
61a: b2 01 movw r22, r4
61c: 0e 94 3f 09 call 0x127e ; 0x127e <__divsf3>
620: 56 2e mov r5, r22
622: 47 2e mov r4, r23
624: 68 2e mov r6, r24
626: 79 2e mov r7, r25
628: 86 2f mov r24, r22
62a: 94 2d mov r25, r4
62c: a6 2d mov r26, r6
62e: b7 2d mov r27, r7
630: c4 57 subi r28, 0x74 ; 116
632: df 4f sbci r29, 0xFF ; 255
634: 88 83 st Y, r24
636: 99 83 std Y+1, r25 ; 0x01
638: aa 83 std Y+2, r26 ; 0x02
63a: bb 83 std Y+3, r27 ; 0x03
63c: cc 58 subi r28, 0x8C ; 140
63e: d0 40 sbci r29, 0x00 ; 0
return (m * (float)v) + (-m * v1) + c1;
640: b7 01 movw r22, r14
642: 80 e0 ldi r24, 0x00 ; 0
644: 90 e0 ldi r25, 0x00 ; 0
646: 0e 94 d3 09 call 0x13a6 ; 0x13a6 <__floatunsisf>
64a: 9b 01 movw r18, r22
64c: ac 01 movw r20, r24
64e: 65 2d mov r22, r5
650: 74 2d mov r23, r4
652: 86 2d mov r24, r6
654: 97 2d mov r25, r7
656: 0e 94 89 0a call 0x1512 ; 0x1512 <__mulsf3>
65a: 2b 01 movw r4, r22
65c: 3c 01 movw r6, r24
65e: c4 57 subi r28, 0x74 ; 116
660: df 4f sbci r29, 0xFF ; 255
662: 28 81 ld r18, Y
664: 39 81 ldd r19, Y+1 ; 0x01
666: 4a 81 ldd r20, Y+2 ; 0x02
668: 5b 81 ldd r21, Y+3 ; 0x03
66a: cc 58 subi r28, 0x8C ; 140
66c: d0 40 sbci r29, 0x00 ; 0
66e: 50 58 subi r21, 0x80 ; 128
670: 60 2f mov r22, r16
672: 71 2f mov r23, r17
674: 89 2d mov r24, r9
676: 98 2d mov r25, r8
678: 0e 94 89 0a call 0x1512 ; 0x1512 <__mulsf3>
67c: 9b 01 movw r18, r22
67e: ac 01 movw r20, r24
680: c3 01 movw r24, r6
682: b2 01 movw r22, r4
684: 0e 94 d7 08 call 0x11ae ; 0x11ae <__addsf3>
688: 9b 01 movw r18, r22
68a: ac 01 movw r20, r24
68c: c6 57 subi r28, 0x76 ; 118
68e: df 4f sbci r29, 0xFF ; 255
690: f8 81 ld r31, Y
692: ca 58 subi r28, 0x8A ; 138
694: d0 40 sbci r29, 0x00 ; 0
696: c5 57 subi r28, 0x75 ; 117
698: df 4f sbci r29, 0xFF ; 255
69a: e8 81 ld r30, Y
69c: cb 58 subi r28, 0x8B ; 139
69e: d0 40 sbci r29, 0x00 ; 0
6a0: 63 2d mov r22, r3
6a2: 72 2d mov r23, r2
6a4: 8f 2f mov r24, r31
6a6: 9e 2f mov r25, r30
6a8: 0e 94 d7 08 call 0x11ae ; 0x11ae <__addsf3>
6ac: c4 57 subi r28, 0x74 ; 116
6ae: df 4f sbci r29, 0xFF ; 255
6b0: 68 83 st Y, r22
6b2: cc 58 subi r28, 0x8C ; 140
6b4: d0 40 sbci r29, 0x00 ; 0
6b6: c8 56 subi r28, 0x68 ; 104
6b8: df 4f sbci r29, 0xFF ; 255
6ba: 78 83 st Y, r23
6bc: c8 59 subi r28, 0x98 ; 152
6be: d0 40 sbci r29, 0x00 ; 0
6c0: c7 56 subi r28, 0x67 ; 103
6c2: df 4f sbci r29, 0xFF ; 255
6c4: 88 83 st Y, r24
6c6: c9 59 subi r28, 0x99 ; 153
6c8: d0 40 sbci r29, 0x00 ; 0
6ca: c6 56 subi r28, 0x66 ; 102
6cc: df 4f sbci r29, 0xFF ; 255
6ce: 98 83 st Y, r25
6d0: ca 59 subi r28, 0x9A ; 154
6d2: d0 40 sbci r29, 0x00 ; 0
loop_until_bit_is_set(ADCSRA, ADIF);
//ADCSRA |= (1<<ADIF);
return ADCW;
}
float convert(uint16_t v, uint8_t pin) {
float c1 = this->table[pin][0];
6d4: 60 91 ab 01 lds r22, 0x01AB
6d8: 70 91 ac 01 lds r23, 0x01AC
6dc: 80 e0 ldi r24, 0x00 ; 0
6de: 90 e0 ldi r25, 0x00 ; 0
6e0: 0e 94 d3 09 call 0x13a6 ; 0x13a6 <__floatunsisf>
6e4: 36 2e mov r3, r22
6e6: 27 2e mov r2, r23
6e8: c6 57 subi r28, 0x76 ; 118
6ea: df 4f sbci r29, 0xFF ; 255
6ec: 88 83 st Y, r24
6ee: ca 58 subi r28, 0x8A ; 138
6f0: d0 40 sbci r29, 0x00 ; 0
6f2: c5 57 subi r28, 0x75 ; 117
6f4: df 4f sbci r29, 0xFF ; 255
6f6: 98 83 st Y, r25
6f8: cb 58 subi r28, 0x8B ; 139
6fa: d0 40 sbci r29, 0x00 ; 0
float v1 = this->table[pin][1];
6fc: 60 91 ad 01 lds r22, 0x01AD
700: 70 91 ae 01 lds r23, 0x01AE
704: 80 e0 ldi r24, 0x00 ; 0
706: 90 e0 ldi r25, 0x00 ; 0
708: 0e 94 d3 09 call 0x13a6 ; 0x13a6 <__floatunsisf>
70c: 06 2f mov r16, r22
70e: 17 2f mov r17, r23
710: 98 2e mov r9, r24
712: 89 2e mov r8, r25
float c2 = this->table[pin][2];
714: 60 91 af 01 lds r22, 0x01AF
718: 70 91 b0 01 lds r23, 0x01B0
71c: 80 e0 ldi r24, 0x00 ; 0
71e: 90 e0 ldi r25, 0x00 ; 0
720: 0e 94 d3 09 call 0x13a6 ; 0x13a6 <__floatunsisf>
724: 9b 01 movw r18, r22
726: ac 01 movw r20, r24
float v2 = this->table[pin][3];
float m = ((c1 - c2) / (v1 - v2));
728: c6 57 subi r28, 0x76 ; 118
72a: df 4f sbci r29, 0xFF ; 255
72c: f8 81 ld r31, Y
72e: ca 58 subi r28, 0x8A ; 138
730: d0 40 sbci r29, 0x00 ; 0
732: c5 57 subi r28, 0x75 ; 117
734: df 4f sbci r29, 0xFF ; 255
736: e8 81 ld r30, Y
738: cb 58 subi r28, 0x8B ; 139
73a: d0 40 sbci r29, 0x00 ; 0
73c: 63 2d mov r22, r3
73e: 72 2d mov r23, r2
740: 8f 2f mov r24, r31
742: 9e 2f mov r25, r30
744: 0e 94 d6 08 call 0x11ac ; 0x11ac <__subsf3>
748: 2b 01 movw r4, r22
74a: 3c 01 movw r6, r24
float convert(uint16_t v, uint8_t pin) {
float c1 = this->table[pin][0];
float v1 = this->table[pin][1];
float c2 = this->table[pin][2];
float v2 = this->table[pin][3];
74c: 60 91 b1 01 lds r22, 0x01B1
750: 70 91 b2 01 lds r23, 0x01B2
754: 80 e0 ldi r24, 0x00 ; 0
756: 90 e0 ldi r25, 0x00 ; 0
758: 0e 94 d3 09 call 0x13a6 ; 0x13a6 <__floatunsisf>
75c: 9b 01 movw r18, r22
75e: ac 01 movw r20, r24
float m = ((c1 - c2) / (v1 - v2));
760: 60 2f mov r22, r16
762: 71 2f mov r23, r17
764: 89 2d mov r24, r9
766: 98 2d mov r25, r8
768: 0e 94 d6 08 call 0x11ac ; 0x11ac <__subsf3>
76c: 9b 01 movw r18, r22
76e: ac 01 movw r20, r24
770: c3 01 movw r24, r6
772: b2 01 movw r22, r4
774: 0e 94 3f 09 call 0x127e ; 0x127e <__divsf3>
778: 56 2e mov r5, r22
77a: 47 2e mov r4, r23
77c: 68 2e mov r6, r24
77e: 79 2e mov r7, r25
780: 86 2f mov r24, r22
782: 94 2d mov r25, r4
784: a6 2d mov r26, r6
786: b7 2d mov r27, r7
788: c0 57 subi r28, 0x70 ; 112
78a: df 4f sbci r29, 0xFF ; 255
78c: 88 83 st Y, r24
78e: 99 83 std Y+1, r25 ; 0x01
790: aa 83 std Y+2, r26 ; 0x02
792: bb 83 std Y+3, r27 ; 0x03
794: c0 59 subi r28, 0x90 ; 144
796: d0 40 sbci r29, 0x00 ; 0
return (m * (float)v) + (-m * v1) + c1;
798: b6 01 movw r22, r12
79a: 80 e0 ldi r24, 0x00 ; 0
79c: 90 e0 ldi r25, 0x00 ; 0
79e: 0e 94 d3 09 call 0x13a6 ; 0x13a6 <__floatunsisf>
7a2: 9b 01 movw r18, r22
7a4: ac 01 movw r20, r24
7a6: 65 2d mov r22, r5
7a8: 74 2d mov r23, r4
7aa: 86 2d mov r24, r6
7ac: 97 2d mov r25, r7
7ae: 0e 94 89 0a call 0x1512 ; 0x1512 <__mulsf3>
7b2: 2b 01 movw r4, r22
7b4: 3c 01 movw r6, r24
7b6: c0 57 subi r28, 0x70 ; 112
7b8: df 4f sbci r29, 0xFF ; 255
7ba: 28 81 ld r18, Y
7bc: 39 81 ldd r19, Y+1 ; 0x01
7be: 4a 81 ldd r20, Y+2 ; 0x02
7c0: 5b 81 ldd r21, Y+3 ; 0x03
7c2: c0 59 subi r28, 0x90 ; 144
7c4: d0 40 sbci r29, 0x00 ; 0
7c6: 50 58 subi r21, 0x80 ; 128
7c8: 60 2f mov r22, r16
7ca: 71 2f mov r23, r17
7cc: 89 2d mov r24, r9
7ce: 98 2d mov r25, r8
7d0: 0e 94 89 0a call 0x1512 ; 0x1512 <__mulsf3>
7d4: 9b 01 movw r18, r22
7d6: ac 01 movw r20, r24
7d8: c3 01 movw r24, r6
7da: b2 01 movw r22, r4
7dc: 0e 94 d7 08 call 0x11ae ; 0x11ae <__addsf3>
7e0: 9b 01 movw r18, r22
7e2: ac 01 movw r20, r24
7e4: c6 57 subi r28, 0x76 ; 118
7e6: df 4f sbci r29, 0xFF ; 255
7e8: f8 81 ld r31, Y
7ea: ca 58 subi r28, 0x8A ; 138
7ec: d0 40 sbci r29, 0x00 ; 0
7ee: c5 57 subi r28, 0x75 ; 117
7f0: df 4f sbci r29, 0xFF ; 255
7f2: e8 81 ld r30, Y
7f4: cb 58 subi r28, 0x8B ; 139
7f6: d0 40 sbci r29, 0x00 ; 0
7f8: 63 2d mov r22, r3
7fa: 72 2d mov r23, r2
7fc: 8f 2f mov r24, r31
7fe: 9e 2f mov r25, r30
800: 0e 94 d7 08 call 0x11ae ; 0x11ae <__addsf3>
804: c0 57 subi r28, 0x70 ; 112
806: df 4f sbci r29, 0xFF ; 255
808: 68 83 st Y, r22
80a: c0 59 subi r28, 0x90 ; 144
80c: d0 40 sbci r29, 0x00 ; 0
80e: c5 56 subi r28, 0x65 ; 101
810: df 4f sbci r29, 0xFF ; 255
812: 78 83 st Y, r23
814: cb 59 subi r28, 0x9B ; 155
816: d0 40 sbci r29, 0x00 ; 0
818: c4 56 subi r28, 0x64 ; 100
81a: df 4f sbci r29, 0xFF ; 255
81c: 88 83 st Y, r24
81e: cc 59 subi r28, 0x9C ; 156
820: d0 40 sbci r29, 0x00 ; 0
822: c3 56 subi r28, 0x63 ; 99
824: df 4f sbci r29, 0xFF ; 255
826: 98 83 st Y, r25
828: cd 59 subi r28, 0x9D ; 157
82a: d0 40 sbci r29, 0x00 ; 0
o.stop();
while(true) {};
}
float t0 = a.convert(v0, 0);
float t1 = a.convert(v1, 1);
float tm = (t0+t1)/2;
82c: 76 2f mov r23, r22
82e: c5 56 subi r28, 0x65 ; 101
830: df 4f sbci r29, 0xFF ; 255
832: 68 81 ld r22, Y
834: cb 59 subi r28, 0x9B ; 155
836: d0 40 sbci r29, 0x00 ; 0
838: 98 2f mov r25, r24
83a: c3 56 subi r28, 0x63 ; 99
83c: df 4f sbci r29, 0xFF ; 255
83e: 88 81 ld r24, Y
840: cd 59 subi r28, 0x9D ; 157
842: d0 40 sbci r29, 0x00 ; 0
844: 27 2f mov r18, r23
846: 36 2f mov r19, r22
848: 49 2f mov r20, r25
84a: 58 2f mov r21, r24
84c: c4 57 subi r28, 0x74 ; 116
84e: df 4f sbci r29, 0xFF ; 255
850: b8 81 ld r27, Y
852: cc 58 subi r28, 0x8C ; 140
854: d0 40 sbci r29, 0x00 ; 0
856: c8 56 subi r28, 0x68 ; 104
858: df 4f sbci r29, 0xFF ; 255
85a: a8 81 ld r26, Y
85c: c8 59 subi r28, 0x98 ; 152
85e: d0 40 sbci r29, 0x00 ; 0
860: c7 56 subi r28, 0x67 ; 103
862: df 4f sbci r29, 0xFF ; 255
864: f8 81 ld r31, Y
866: c9 59 subi r28, 0x99 ; 153
868: d0 40 sbci r29, 0x00 ; 0
86a: c6 56 subi r28, 0x66 ; 102
86c: df 4f sbci r29, 0xFF ; 255
86e: e8 81 ld r30, Y
870: ca 59 subi r28, 0x9A ; 154
872: d0 40 sbci r29, 0x00 ; 0
874: 6b 2f mov r22, r27
876: 7a 2f mov r23, r26
878: 8f 2f mov r24, r31
87a: 9e 2f mov r25, r30
87c: 0e 94 d7 08 call 0x11ae ; 0x11ae <__addsf3>
880: 20 e0 ldi r18, 0x00 ; 0
882: 30 e0 ldi r19, 0x00 ; 0
884: 40 e0 ldi r20, 0x00 ; 0
886: 5f e3 ldi r21, 0x3F ; 63
888: 0e 94 89 0a call 0x1512 ; 0x1512 <__mulsf3>
88c: c2 56 subi r28, 0x62 ; 98
88e: df 4f sbci r29, 0xFF ; 255
890: 68 83 st Y, r22
892: ce 59 subi r28, 0x9E ; 158
894: d0 40 sbci r29, 0x00 ; 0
896: c1 56 subi r28, 0x61 ; 97
898: df 4f sbci r29, 0xFF ; 255
89a: 78 83 st Y, r23
89c: cf 59 subi r28, 0x9F ; 159
89e: d0 40 sbci r29, 0x00 ; 0
8a0: c0 56 subi r28, 0x60 ; 96
8a2: df 4f sbci r29, 0xFF ; 255
8a4: 88 83 st Y, r24
8a6: c0 5a subi r28, 0xA0 ; 160
8a8: d0 40 sbci r29, 0x00 ; 0
8aa: cf 55 subi r28, 0x5F ; 95
8ac: df 4f sbci r29, 0xFF ; 255
8ae: 98 83 st Y, r25
8b0: c1 5a subi r28, 0xA1 ; 161
8b2: d0 40 sbci r29, 0x00 ; 0
}
void send(uint8_t wert) {
uart_putchar(wert);
}
int16_t readTemp() {
int16_t t = this->temp;
8b4: e4 ed ldi r30, 0xD4 ; 212
8b6: f1 e0 ldi r31, 0x01 ; 1
8b8: 80 81 ld r24, Z
8ba: 91 81 ldd r25, Z+1 ; 0x01
this->temp = -1;
8bc: 2f ef ldi r18, 0xFF ; 255
8be: 3f ef ldi r19, 0xFF ; 255
8c0: 31 83 std Z+1, r19 ; 0x01
8c2: 20 83 st Z, r18
int16_t temp = r.readTemp();
if(temp != -1) {
8c4: 8f 3f cpi r24, 0xFF ; 255
8c6: ff ef ldi r31, 0xFF ; 255
8c8: 9f 07 cpc r25, r31
8ca: 31 f0 breq .+12 ; 0x8d8 <__stack+0x479>
target_temp = temp;
8cc: cc 56 subi r28, 0x6C ; 108
8ce: df 4f sbci r29, 0xFF ; 255
8d0: 99 83 std Y+1, r25 ; 0x01
8d2: 88 83 st Y, r24
8d4: c4 59 subi r28, 0x94 ; 148
8d6: d0 40 sbci r29, 0x00 ; 0
return t;
}
int8_t readMotor() {
int8_t m = this->motor;
8d8: e6 ed ldi r30, 0xD6 ; 214
8da: f1 e0 ldi r31, 0x01 ; 1
8dc: 80 81 ld r24, Z
this->motor = -1;
8de: 9f ef ldi r25, 0xFF ; 255
8e0: 90 83 st Z, r25
}
int8_t motor = r.readMotor();
if(motor != -1) {
8e2: 8f 3f cpi r24, 0xFF ; 255
8e4: 29 f0 breq .+10 ; 0x8f0 <__stack+0x491>
target_motor = motor;
8e6: ca 56 subi r28, 0x6A ; 106
8e8: df 4f sbci r29, 0xFF ; 255
8ea: 88 83 st Y, r24
8ec: c6 59 subi r28, 0x96 ; 150
8ee: d0 40 sbci r29, 0x00 ; 0
}
pwm_value = (target_temp+5) - tm;
8f0: cc 56 subi r28, 0x6C ; 108
8f2: df 4f sbci r29, 0xFF ; 255
8f4: 68 81 ld r22, Y
8f6: 79 81 ldd r23, Y+1 ; 0x01
8f8: c4 59 subi r28, 0x94 ; 148
8fa: d0 40 sbci r29, 0x00 ; 0
8fc: 6b 5f subi r22, 0xFB ; 251
8fe: 7f 4f sbci r23, 0xFF ; 255
900: 88 27 eor r24, r24
902: 77 fd sbrc r23, 7
904: 80 95 com r24
906: 98 2f mov r25, r24
908: 0e 94 d5 09 call 0x13aa ; 0x13aa <__floatsisf>
90c: c2 56 subi r28, 0x62 ; 98
90e: df 4f sbci r29, 0xFF ; 255
910: b8 81 ld r27, Y
912: ce 59 subi r28, 0x9E ; 158
914: d0 40 sbci r29, 0x00 ; 0
916: c1 56 subi r28, 0x61 ; 97
918: df 4f sbci r29, 0xFF ; 255
91a: a8 81 ld r26, Y
91c: cf 59 subi r28, 0x9F ; 159
91e: d0 40 sbci r29, 0x00 ; 0
920: c0 56 subi r28, 0x60 ; 96
922: df 4f sbci r29, 0xFF ; 255
924: f8 81 ld r31, Y
926: c0 5a subi r28, 0xA0 ; 160
928: d0 40 sbci r29, 0x00 ; 0
92a: cf 55 subi r28, 0x5F ; 95
92c: df 4f sbci r29, 0xFF ; 255
92e: e8 81 ld r30, Y
930: c1 5a subi r28, 0xA1 ; 161
932: d0 40 sbci r29, 0x00 ; 0
934: 2b 2f mov r18, r27
936: 3a 2f mov r19, r26
938: 4f 2f mov r20, r31
93a: 5e 2f mov r21, r30
93c: 0e 94 d6 08 call 0x11ac ; 0x11ac <__subsf3>
940: 96 2e mov r9, r22
942: 87 2e mov r8, r23
944: 78 2e mov r7, r24
946: 69 2e mov r6, r25
void setPwm(uint8_t ausg, float val) {
if(ausg < 0)
ausg = 0;
if(ausg > 5)
ausg = 5;
if(val < 0)
948: 20 e0 ldi r18, 0x00 ; 0
94a: 30 e0 ldi r19, 0x00 ; 0
94c: a9 01 movw r20, r18
94e: 0e 94 3b 09 call 0x1276 ; 0x1276 <__cmpsf2>
952: 88 23 and r24, r24
954: 8c f0 brlt .+34 ; 0x978 <__stack+0x519>
val = 0;
if(val > 20)
956: 20 e0 ldi r18, 0x00 ; 0
958: 30 e0 ldi r19, 0x00 ; 0
95a: 40 ea ldi r20, 0xA0 ; 160
95c: 51 e4 ldi r21, 0x41 ; 65
95e: 69 2d mov r22, r9
960: 78 2d mov r23, r8
962: 87 2d mov r24, r7
964: 96 2d mov r25, r6
966: 0e 94 85 0a call 0x150a ; 0x150a <__gesf2>
96a: 18 16 cp r1, r24
96c: 54 f0 brlt .+20 ; 0x982 <__stack+0x523>
96e: 39 2d mov r19, r9
970: 28 2d mov r18, r8
972: 97 2d mov r25, r7
974: 86 2d mov r24, r6
976: 09 c0 rjmp .+18 ; 0x98a <__stack+0x52b>
if(ausg < 0)
ausg = 0;
if(ausg > 5)
ausg = 5;
if(val < 0)
val = 0;
978: 30 e0 ldi r19, 0x00 ; 0
97a: 20 e0 ldi r18, 0x00 ; 0
97c: 90 e0 ldi r25, 0x00 ; 0
97e: 80 e0 ldi r24, 0x00 ; 0
980: 04 c0 rjmp .+8 ; 0x98a <__stack+0x52b>
if(val > 20)
val = 20;
982: 30 e0 ldi r19, 0x00 ; 0
984: 20 e0 ldi r18, 0x00 ; 0
986: 90 ea ldi r25, 0xA0 ; 160
988: 81 e4 ldi r24, 0x41 ; 65
this->pwm[ausg] = (uint8_t)val;
98a: 48 2f mov r20, r24
98c: 63 2f mov r22, r19
98e: 72 2f mov r23, r18
990: 89 2f mov r24, r25
992: 94 2f mov r25, r20
994: 0e 94 a7 09 call 0x134e ; 0x134e <__fixunssfsi>
998: 60 93 de 01 sts 0x01DE, r22
o.setPwm(0, pwm_value);
o.setPwm(1, target_motor);
99c: ca 56 subi r28, 0x6A ; 106
99e: df 4f sbci r29, 0xFF ; 255
9a0: 28 81 ld r18, Y
9a2: c6 59 subi r28, 0x96 ; 150
9a4: d0 40 sbci r29, 0x00 ; 0
9a6: 62 2f mov r22, r18
9a8: 77 27 eor r23, r23
9aa: 67 fd sbrc r22, 7
9ac: 70 95 com r23
9ae: 87 2f mov r24, r23
9b0: 97 2f mov r25, r23
9b2: 0e 94 d5 09 call 0x13aa ; 0x13aa <__floatsisf>
9b6: 26 2e mov r2, r22
9b8: 37 2e mov r3, r23
9ba: 08 2f mov r16, r24
9bc: 19 2f mov r17, r25
9be: 46 2e mov r4, r22
9c0: 57 2e mov r5, r23
9c2: c6 57 subi r28, 0x76 ; 118
9c4: df 4f sbci r29, 0xFF ; 255
9c6: 88 83 st Y, r24
9c8: ca 58 subi r28, 0x8A ; 138
9ca: d0 40 sbci r29, 0x00 ; 0
9cc: c5 57 subi r28, 0x75 ; 117
9ce: df 4f sbci r29, 0xFF ; 255
9d0: 98 83 st Y, r25
9d2: cb 58 subi r28, 0x8B ; 139
9d4: d0 40 sbci r29, 0x00 ; 0
void setPwm(uint8_t ausg, float val) {
if(ausg < 0)
ausg = 0;
if(ausg > 5)
ausg = 5;
if(val < 0)
9d6: 20 e0 ldi r18, 0x00 ; 0
9d8: 30 e0 ldi r19, 0x00 ; 0
9da: a9 01 movw r20, r18
9dc: 0e 94 3b 09 call 0x1276 ; 0x1276 <__cmpsf2>
9e0: 88 23 and r24, r24
9e2: 0c f4 brge .+2 ; 0x9e6 <__stack+0x587>
9e4: 39 c2 rjmp .+1138 ; 0xe58 <__stack+0x9f9>
val = 0;
if(val > 20)
9e6: 20 e0 ldi r18, 0x00 ; 0
9e8: 30 e0 ldi r19, 0x00 ; 0
9ea: 40 ea ldi r20, 0xA0 ; 160
9ec: 51 e4 ldi r21, 0x41 ; 65
9ee: 62 2d mov r22, r2
9f0: 73 2d mov r23, r3
9f2: 80 2f mov r24, r16
9f4: 91 2f mov r25, r17
9f6: 0e 94 85 0a call 0x150a ; 0x150a <__gesf2>
9fa: 18 16 cp r1, r24
9fc: 0c f4 brge .+2 ; 0xa00 <__stack+0x5a1>
9fe: 39 c2 rjmp .+1138 ; 0xe72 <__stack+0xa13>
a00: 46 c2 rjmp .+1164 ; 0xe8e <__stack+0xa2f>
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
a02: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
a04: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
a06: 5d 9b sbis 0x0b, 5 ; 11
a08: fe cf rjmp .-4 ; 0xa06 <__stack+0x5a7>
UDR = c;
a0a: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
a0c: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
a0e: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
a10: 81 91 ld r24, Z+
a12: 81 11 cpse r24, r1
a14: f6 cf rjmp .-20 ; 0xa02 <__stack+0x5a3>
char pw[11]; r.send("pwm="); r.send(dtostrf(pwm_value, 10, 2, pw)); r.send(";");
a16: 8e 01 movw r16, r28
a18: 03 58 subi r16, 0x83 ; 131
a1a: 1f 4f sbci r17, 0xFF ; 255
a1c: 22 e0 ldi r18, 0x02 ; 2
a1e: 4a e0 ldi r20, 0x0A ; 10
a20: 69 2d mov r22, r9
a22: 78 2d mov r23, r8
a24: 87 2d mov r24, r7
a26: 96 2d mov r25, r6
a28: 0e 94 26 0b call 0x164c ; 0x164c <dtostrf>
a2c: dc 01 movw r26, r24
a2e: 2c 91 ld r18, X
a30: 22 23 and r18, r18
a32: 61 f0 breq .+24 ; 0xa4c <__stack+0x5ed>
l.off(l.YELLOW);
r.send("#### End Bootup ###########################################\n");
l.on(l.GREEN);
}
int main(void)
a34: fc 01 movw r30, r24
a36: 31 96 adiw r30, 0x01 ; 1
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
a38: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
a3a: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
a3c: 5d 9b sbis 0x0b, 5 ; 11
a3e: fe cf rjmp .-4 ; 0xa3c <__stack+0x5dd>
UDR = c;
a40: 2c b9 out 0x0c, r18 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
a42: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
a44: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
a46: 21 91 ld r18, Z+
a48: 21 11 cpse r18, r1
a4a: f6 cf rjmp .-20 ; 0xa38 <__stack+0x5d9>
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
a4c: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
a4e: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
a50: 5d 9b sbis 0x0b, 5 ; 11
a52: fe cf rjmp .-4 ; 0xa50 <__stack+0x5f1>
UDR = c;
a54: 8b e3 ldi r24, 0x3B ; 59
a56: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
a58: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
a5a: bb 9a sbi 0x17, 3 ; 23
a5c: e6 e7 ldi r30, 0x76 ; 118
a5e: f1 e0 ldi r31, 0x01 ; 1
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
a60: 86 e7 ldi r24, 0x76 ; 118
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
a62: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
a64: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
a66: 5d 9b sbis 0x0b, 5 ; 11
a68: fe cf rjmp .-4 ; 0xa66 <__stack+0x607>
UDR = c;
a6a: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
a6c: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
a6e: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
a70: 81 91 ld r24, Z+
a72: 81 11 cpse r24, r1
a74: f6 cf rjmp .-20 ; 0xa62 <__stack+0x603>
}
pwm_value = (target_temp+5) - tm;
o.setPwm(0, pwm_value);
o.setPwm(1, target_motor);
char pw[11]; r.send("pwm="); r.send(dtostrf(pwm_value, 10, 2, pw)); r.send(";");
char vs[11]; r.send("vm="); r.send(dtostrf((((float)(v0+v1))/2), 10, 2, vs)); r.send(";");
a76: b6 01 movw r22, r12
a78: 6e 0d add r22, r14
a7a: 7f 1d adc r23, r15
a7c: 80 e0 ldi r24, 0x00 ; 0
a7e: 90 e0 ldi r25, 0x00 ; 0
a80: 0e 94 d3 09 call 0x13a6 ; 0x13a6 <__floatunsisf>
a84: 20 e0 ldi r18, 0x00 ; 0
a86: 30 e0 ldi r19, 0x00 ; 0
a88: 40 e0 ldi r20, 0x00 ; 0
a8a: 5f e3 ldi r21, 0x3F ; 63
a8c: 0e 94 89 0a call 0x1512 ; 0x1512 <__mulsf3>
a90: 8e 01 movw r16, r28
a92: 0e 58 subi r16, 0x8E ; 142
a94: 1f 4f sbci r17, 0xFF ; 255
a96: 22 e0 ldi r18, 0x02 ; 2
a98: 4a e0 ldi r20, 0x0A ; 10
a9a: 0e 94 26 0b call 0x164c ; 0x164c <dtostrf>
a9e: fc 01 movw r30, r24
aa0: 20 81 ld r18, Z
aa2: 22 23 and r18, r18
aa4: 59 f0 breq .+22 ; 0xabc <__stack+0x65d>
l.off(l.YELLOW);
r.send("#### End Bootup ###########################################\n");
l.on(l.GREEN);
}
int main(void)
aa6: 31 96 adiw r30, 0x01 ; 1
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
aa8: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
aaa: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
aac: 5d 9b sbis 0x0b, 5 ; 11
aae: fe cf rjmp .-4 ; 0xaac <__stack+0x64d>
UDR = c;
ab0: 2c b9 out 0x0c, r18 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
ab2: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
ab4: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
ab6: 21 91 ld r18, Z+
ab8: 21 11 cpse r18, r1
aba: f6 cf rjmp .-20 ; 0xaa8 <__stack+0x649>
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
abc: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
abe: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
ac0: 5d 9b sbis 0x0b, 5 ; 11
ac2: fe cf rjmp .-4 ; 0xac0 <__stack+0x661>
UDR = c;
ac4: 8b e3 ldi r24, 0x3B ; 59
ac6: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
ac8: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
aca: bb 9a sbi 0x17, 3 ; 23
acc: ea e7 ldi r30, 0x7A ; 122
ace: f1 e0 ldi r31, 0x01 ; 1
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
ad0: 86 e7 ldi r24, 0x76 ; 118
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
ad2: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
ad4: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
ad6: 5d 9b sbis 0x0b, 5 ; 11
ad8: fe cf rjmp .-4 ; 0xad6 <__stack+0x677>
UDR = c;
ada: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
adc: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
ade: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
ae0: 81 91 ld r24, Z+
ae2: 81 11 cpse r24, r1
ae4: f6 cf rjmp .-20 ; 0xad2 <__stack+0x673>
pwm_value = (target_temp+5) - tm;
o.setPwm(0, pwm_value);
o.setPwm(1, target_motor);
char pw[11]; r.send("pwm="); r.send(dtostrf(pwm_value, 10, 2, pw)); r.send(";");
char vs[11]; r.send("vm="); r.send(dtostrf((((float)(v0+v1))/2), 10, 2, vs)); r.send(";");
r.send("v0="); r.send(utoa(v0, vs, 10)); r.send(";");
ae6: 4a e0 ldi r20, 0x0A ; 10
ae8: 50 e0 ldi r21, 0x00 ; 0
aea: be 01 movw r22, r28
aec: 6e 58 subi r22, 0x8E ; 142
aee: 7f 4f sbci r23, 0xFF ; 255
af0: c7 01 movw r24, r14
af2: 0e 94 47 0b call 0x168e ; 0x168e <utoa>
af6: dc 01 movw r26, r24
af8: 2c 91 ld r18, X
afa: 22 23 and r18, r18
afc: 61 f0 breq .+24 ; 0xb16 <__stack+0x6b7>
l.off(l.YELLOW);
r.send("#### End Bootup ###########################################\n");
l.on(l.GREEN);
}
int main(void)
afe: fc 01 movw r30, r24
b00: 31 96 adiw r30, 0x01 ; 1
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
b02: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
b04: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
b06: 5d 9b sbis 0x0b, 5 ; 11
b08: fe cf rjmp .-4 ; 0xb06 <__stack+0x6a7>
UDR = c;
b0a: 2c b9 out 0x0c, r18 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
b0c: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
b0e: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
b10: 21 91 ld r18, Z+
b12: 21 11 cpse r18, r1
b14: f6 cf rjmp .-20 ; 0xb02 <__stack+0x6a3>
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
b16: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
b18: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
b1a: 5d 9b sbis 0x0b, 5 ; 11
b1c: fe cf rjmp .-4 ; 0xb1a <__stack+0x6bb>
UDR = c;
b1e: 8b e3 ldi r24, 0x3B ; 59
b20: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
b22: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
b24: bb 9a sbi 0x17, 3 ; 23
b26: ee e7 ldi r30, 0x7E ; 126
b28: f1 e0 ldi r31, 0x01 ; 1
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
b2a: 86 e7 ldi r24, 0x76 ; 118
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
b2c: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
b2e: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
b30: 5d 9b sbis 0x0b, 5 ; 11
b32: fe cf rjmp .-4 ; 0xb30 <__stack+0x6d1>
UDR = c;
b34: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
b36: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
b38: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
b3a: 81 91 ld r24, Z+
b3c: 81 11 cpse r24, r1
b3e: f6 cf rjmp .-20 ; 0xb2c <__stack+0x6cd>
o.setPwm(0, pwm_value);
o.setPwm(1, target_motor);
char pw[11]; r.send("pwm="); r.send(dtostrf(pwm_value, 10, 2, pw)); r.send(";");
char vs[11]; r.send("vm="); r.send(dtostrf((((float)(v0+v1))/2), 10, 2, vs)); r.send(";");
r.send("v0="); r.send(utoa(v0, vs, 10)); r.send(";");
r.send("v1="); r.send(utoa(v1, vs, 10)); r.send(";");
b40: 4a e0 ldi r20, 0x0A ; 10
b42: 50 e0 ldi r21, 0x00 ; 0
b44: be 01 movw r22, r28
b46: 6e 58 subi r22, 0x8E ; 142
b48: 7f 4f sbci r23, 0xFF ; 255
b4a: c6 01 movw r24, r12
b4c: 0e 94 47 0b call 0x168e ; 0x168e <utoa>
b50: fc 01 movw r30, r24
b52: 20 81 ld r18, Z
b54: 22 23 and r18, r18
b56: 59 f0 breq .+22 ; 0xb6e <__stack+0x70f>
l.off(l.YELLOW);
r.send("#### End Bootup ###########################################\n");
l.on(l.GREEN);
}
int main(void)
b58: 31 96 adiw r30, 0x01 ; 1
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
b5a: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
b5c: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
b5e: 5d 9b sbis 0x0b, 5 ; 11
b60: fe cf rjmp .-4 ; 0xb5e <__stack+0x6ff>
UDR = c;
b62: 2c b9 out 0x0c, r18 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
b64: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
b66: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
b68: 21 91 ld r18, Z+
b6a: 21 11 cpse r18, r1
b6c: f6 cf rjmp .-20 ; 0xb5a <__stack+0x6fb>
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
b6e: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
b70: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
b72: 5d 9b sbis 0x0b, 5 ; 11
b74: fe cf rjmp .-4 ; 0xb72 <__stack+0x713>
UDR = c;
b76: 8b e3 ldi r24, 0x3B ; 59
b78: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
b7a: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
b7c: bb 9a sbi 0x17, 3 ; 23
b7e: e2 e8 ldi r30, 0x82 ; 130
b80: f1 e0 ldi r31, 0x01 ; 1
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
b82: 83 e6 ldi r24, 0x63 ; 99
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
b84: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
b86: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
b88: 5d 9b sbis 0x0b, 5 ; 11
b8a: fe cf rjmp .-4 ; 0xb88 <__stack+0x729>
UDR = c;
b8c: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
b8e: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
b90: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
b92: 81 91 ld r24, Z+
b94: 81 11 cpse r24, r1
b96: f6 cf rjmp .-20 ; 0xb84 <__stack+0x725>
o.setPwm(1, target_motor);
char pw[11]; r.send("pwm="); r.send(dtostrf(pwm_value, 10, 2, pw)); r.send(";");
char vs[11]; r.send("vm="); r.send(dtostrf((((float)(v0+v1))/2), 10, 2, vs)); r.send(";");
r.send("v0="); r.send(utoa(v0, vs, 10)); r.send(";");
r.send("v1="); r.send(utoa(v1, vs, 10)); r.send(";");
char cs[11]; r.send("cm="); r.send(dtostrf(tm, 10, 2, cs)); r.send(";");
b98: 8e 01 movw r16, r28
b9a: 09 59 subi r16, 0x99 ; 153
b9c: 1f 4f sbci r17, 0xFF ; 255
b9e: 22 e0 ldi r18, 0x02 ; 2
ba0: 4a e0 ldi r20, 0x0A ; 10
ba2: c2 56 subi r28, 0x62 ; 98
ba4: df 4f sbci r29, 0xFF ; 255
ba6: f8 81 ld r31, Y
ba8: ce 59 subi r28, 0x9E ; 158
baa: d0 40 sbci r29, 0x00 ; 0
bac: c1 56 subi r28, 0x61 ; 97
bae: df 4f sbci r29, 0xFF ; 255
bb0: e8 81 ld r30, Y
bb2: cf 59 subi r28, 0x9F ; 159
bb4: d0 40 sbci r29, 0x00 ; 0
bb6: c0 56 subi r28, 0x60 ; 96
bb8: df 4f sbci r29, 0xFF ; 255
bba: 58 81 ld r21, Y
bbc: c0 5a subi r28, 0xA0 ; 160
bbe: d0 40 sbci r29, 0x00 ; 0
bc0: cf 55 subi r28, 0x5F ; 95
bc2: df 4f sbci r29, 0xFF ; 255
bc4: 38 81 ld r19, Y
bc6: c1 5a subi r28, 0xA1 ; 161
bc8: d0 40 sbci r29, 0x00 ; 0
bca: 6f 2f mov r22, r31
bcc: 7e 2f mov r23, r30
bce: 85 2f mov r24, r21
bd0: 93 2f mov r25, r19
bd2: 0e 94 26 0b call 0x164c ; 0x164c <dtostrf>
bd6: dc 01 movw r26, r24
bd8: 2c 91 ld r18, X
bda: 22 23 and r18, r18
bdc: 61 f0 breq .+24 ; 0xbf6 <__stack+0x797>
l.off(l.YELLOW);
r.send("#### End Bootup ###########################################\n");
l.on(l.GREEN);
}
int main(void)
bde: fc 01 movw r30, r24
be0: 31 96 adiw r30, 0x01 ; 1
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
be2: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
be4: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
be6: 5d 9b sbis 0x0b, 5 ; 11
be8: fe cf rjmp .-4 ; 0xbe6 <__stack+0x787>
UDR = c;
bea: 2c b9 out 0x0c, r18 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
bec: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
bee: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
bf0: 21 91 ld r18, Z+
bf2: 21 11 cpse r18, r1
bf4: f6 cf rjmp .-20 ; 0xbe2 <__stack+0x783>
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
bf6: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
bf8: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
bfa: 5d 9b sbis 0x0b, 5 ; 11
bfc: fe cf rjmp .-4 ; 0xbfa <__stack+0x79b>
UDR = c;
bfe: 8b e3 ldi r24, 0x3B ; 59
c00: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
c02: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
c04: bb 9a sbi 0x17, 3 ; 23
c06: e6 e8 ldi r30, 0x86 ; 134
c08: f1 e0 ldi r31, 0x01 ; 1
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
c0a: 83 e6 ldi r24, 0x63 ; 99
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
c0c: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
c0e: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
c10: 5d 9b sbis 0x0b, 5 ; 11
c12: fe cf rjmp .-4 ; 0xc10 <__stack+0x7b1>
UDR = c;
c14: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
c16: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
c18: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
c1a: 81 91 ld r24, Z+
c1c: 81 11 cpse r24, r1
c1e: f6 cf rjmp .-20 ; 0xc0c <__stack+0x7ad>
char pw[11]; r.send("pwm="); r.send(dtostrf(pwm_value, 10, 2, pw)); r.send(";");
char vs[11]; r.send("vm="); r.send(dtostrf((((float)(v0+v1))/2), 10, 2, vs)); r.send(";");
r.send("v0="); r.send(utoa(v0, vs, 10)); r.send(";");
r.send("v1="); r.send(utoa(v1, vs, 10)); r.send(";");
char cs[11]; r.send("cm="); r.send(dtostrf(tm, 10, 2, cs)); r.send(";");
r.send("c0="); r.send(dtostrf(t0, 10, 2, cs)); r.send(";");
c20: 8e 01 movw r16, r28
c22: 09 59 subi r16, 0x99 ; 153
c24: 1f 4f sbci r17, 0xFF ; 255
c26: 22 e0 ldi r18, 0x02 ; 2
c28: 4a e0 ldi r20, 0x0A ; 10
c2a: c4 57 subi r28, 0x74 ; 116
c2c: df 4f sbci r29, 0xFF ; 255
c2e: f8 81 ld r31, Y
c30: cc 58 subi r28, 0x8C ; 140
c32: d0 40 sbci r29, 0x00 ; 0
c34: c8 56 subi r28, 0x68 ; 104
c36: df 4f sbci r29, 0xFF ; 255
c38: e8 81 ld r30, Y
c3a: c8 59 subi r28, 0x98 ; 152
c3c: d0 40 sbci r29, 0x00 ; 0
c3e: c7 56 subi r28, 0x67 ; 103
c40: df 4f sbci r29, 0xFF ; 255
c42: 58 81 ld r21, Y
c44: c9 59 subi r28, 0x99 ; 153
c46: d0 40 sbci r29, 0x00 ; 0
c48: c6 56 subi r28, 0x66 ; 102
c4a: df 4f sbci r29, 0xFF ; 255
c4c: 38 81 ld r19, Y
c4e: ca 59 subi r28, 0x9A ; 154
c50: d0 40 sbci r29, 0x00 ; 0
c52: 6f 2f mov r22, r31
c54: 7e 2f mov r23, r30
c56: 85 2f mov r24, r21
c58: 93 2f mov r25, r19
c5a: 0e 94 26 0b call 0x164c ; 0x164c <dtostrf>
c5e: fc 01 movw r30, r24
c60: 20 81 ld r18, Z
c62: 22 23 and r18, r18
c64: 59 f0 breq .+22 ; 0xc7c <__stack+0x81d>
l.off(l.YELLOW);
r.send("#### End Bootup ###########################################\n");
l.on(l.GREEN);
}
int main(void)
c66: 31 96 adiw r30, 0x01 ; 1
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
c68: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
c6a: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
c6c: 5d 9b sbis 0x0b, 5 ; 11
c6e: fe cf rjmp .-4 ; 0xc6c <__stack+0x80d>
UDR = c;
c70: 2c b9 out 0x0c, r18 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
c72: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
c74: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
c76: 21 91 ld r18, Z+
c78: 21 11 cpse r18, r1
c7a: f6 cf rjmp .-20 ; 0xc68 <__stack+0x809>
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
c7c: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
c7e: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
c80: 5d 9b sbis 0x0b, 5 ; 11
c82: fe cf rjmp .-4 ; 0xc80 <__stack+0x821>
UDR = c;
c84: 8b e3 ldi r24, 0x3B ; 59
c86: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
c88: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
c8a: bb 9a sbi 0x17, 3 ; 23
c8c: ea e8 ldi r30, 0x8A ; 138
c8e: f1 e0 ldi r31, 0x01 ; 1
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
c90: 83 e6 ldi r24, 0x63 ; 99
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
c92: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
c94: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
c96: 5d 9b sbis 0x0b, 5 ; 11
c98: fe cf rjmp .-4 ; 0xc96 <__stack+0x837>
UDR = c;
c9a: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
c9c: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
c9e: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
ca0: 81 91 ld r24, Z+
ca2: 81 11 cpse r24, r1
ca4: f6 cf rjmp .-20 ; 0xc92 <__stack+0x833>
char vs[11]; r.send("vm="); r.send(dtostrf((((float)(v0+v1))/2), 10, 2, vs)); r.send(";");
r.send("v0="); r.send(utoa(v0, vs, 10)); r.send(";");
r.send("v1="); r.send(utoa(v1, vs, 10)); r.send(";");
char cs[11]; r.send("cm="); r.send(dtostrf(tm, 10, 2, cs)); r.send(";");
r.send("c0="); r.send(dtostrf(t0, 10, 2, cs)); r.send(";");
r.send("c1="); r.send(dtostrf(t1, 10, 2, cs)); r.send(";");
ca6: 8e 01 movw r16, r28
ca8: 09 59 subi r16, 0x99 ; 153
caa: 1f 4f sbci r17, 0xFF ; 255
cac: 22 e0 ldi r18, 0x02 ; 2
cae: 4a e0 ldi r20, 0x0A ; 10
cb0: c0 57 subi r28, 0x70 ; 112
cb2: df 4f sbci r29, 0xFF ; 255
cb4: f8 81 ld r31, Y
cb6: c0 59 subi r28, 0x90 ; 144
cb8: d0 40 sbci r29, 0x00 ; 0
cba: c5 56 subi r28, 0x65 ; 101
cbc: df 4f sbci r29, 0xFF ; 255
cbe: e8 81 ld r30, Y
cc0: cb 59 subi r28, 0x9B ; 155
cc2: d0 40 sbci r29, 0x00 ; 0
cc4: c4 56 subi r28, 0x64 ; 100
cc6: df 4f sbci r29, 0xFF ; 255
cc8: 58 81 ld r21, Y
cca: cc 59 subi r28, 0x9C ; 156
ccc: d0 40 sbci r29, 0x00 ; 0
cce: c3 56 subi r28, 0x63 ; 99
cd0: df 4f sbci r29, 0xFF ; 255
cd2: 38 81 ld r19, Y
cd4: cd 59 subi r28, 0x9D ; 157
cd6: d0 40 sbci r29, 0x00 ; 0
cd8: 6f 2f mov r22, r31
cda: 7e 2f mov r23, r30
cdc: 85 2f mov r24, r21
cde: 93 2f mov r25, r19
ce0: 0e 94 26 0b call 0x164c ; 0x164c <dtostrf>
ce4: dc 01 movw r26, r24
ce6: 2c 91 ld r18, X
ce8: 22 23 and r18, r18
cea: 61 f0 breq .+24 ; 0xd04 <__stack+0x8a5>
l.off(l.YELLOW);
r.send("#### End Bootup ###########################################\n");
l.on(l.GREEN);
}
int main(void)
cec: fc 01 movw r30, r24
cee: 31 96 adiw r30, 0x01 ; 1
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
cf0: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
cf2: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
cf4: 5d 9b sbis 0x0b, 5 ; 11
cf6: fe cf rjmp .-4 ; 0xcf4 <__stack+0x895>
UDR = c;
cf8: 2c b9 out 0x0c, r18 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
cfa: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
cfc: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
cfe: 21 91 ld r18, Z+
d00: 21 11 cpse r18, r1
d02: f6 cf rjmp .-20 ; 0xcf0 <__stack+0x891>
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
d04: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
d06: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
d08: 5d 9b sbis 0x0b, 5 ; 11
d0a: fe cf rjmp .-4 ; 0xd08 <__stack+0x8a9>
UDR = c;
d0c: 8b e3 ldi r24, 0x3B ; 59
d0e: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
d10: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
d12: bb 9a sbi 0x17, 3 ; 23
d14: ee e8 ldi r30, 0x8E ; 142
d16: f1 e0 ldi r31, 0x01 ; 1
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
d18: 84 e7 ldi r24, 0x74 ; 116
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
d1a: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
d1c: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
d1e: 5d 9b sbis 0x0b, 5 ; 11
d20: fe cf rjmp .-4 ; 0xd1e <__stack+0x8bf>
UDR = c;
d22: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
d24: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
d26: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
d28: 81 91 ld r24, Z+
d2a: 81 11 cpse r24, r1
d2c: f6 cf rjmp .-20 ; 0xd1a <__stack+0x8bb>
r.send("v0="); r.send(utoa(v0, vs, 10)); r.send(";");
r.send("v1="); r.send(utoa(v1, vs, 10)); r.send(";");
char cs[11]; r.send("cm="); r.send(dtostrf(tm, 10, 2, cs)); r.send(";");
r.send("c0="); r.send(dtostrf(t0, 10, 2, cs)); r.send(";");
r.send("c1="); r.send(dtostrf(t1, 10, 2, cs)); r.send(";");
char ts[11]; r.send("t="); r.send(utoa(target_temp, ts, 10)); r.send(";");
d2e: 4a e0 ldi r20, 0x0A ; 10
d30: 50 e0 ldi r21, 0x00 ; 0
d32: be 01 movw r22, r28
d34: 64 5a subi r22, 0xA4 ; 164
d36: 7f 4f sbci r23, 0xFF ; 255
d38: cc 56 subi r28, 0x6C ; 108
d3a: df 4f sbci r29, 0xFF ; 255
d3c: 88 81 ld r24, Y
d3e: 99 81 ldd r25, Y+1 ; 0x01
d40: c4 59 subi r28, 0x94 ; 148
d42: d0 40 sbci r29, 0x00 ; 0
d44: 0e 94 47 0b call 0x168e ; 0x168e <utoa>
d48: fc 01 movw r30, r24
d4a: 20 81 ld r18, Z
d4c: 22 23 and r18, r18
d4e: 59 f0 breq .+22 ; 0xd66 <__stack+0x907>
l.off(l.YELLOW);
r.send("#### End Bootup ###########################################\n");
l.on(l.GREEN);
}
int main(void)
d50: 31 96 adiw r30, 0x01 ; 1
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
d52: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
d54: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
d56: 5d 9b sbis 0x0b, 5 ; 11
d58: fe cf rjmp .-4 ; 0xd56 <__stack+0x8f7>
UDR = c;
d5a: 2c b9 out 0x0c, r18 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
d5c: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
d5e: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
d60: 21 91 ld r18, Z+
d62: 21 11 cpse r18, r1
d64: f6 cf rjmp .-20 ; 0xd52 <__stack+0x8f3>
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
d66: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
d68: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
d6a: 5d 9b sbis 0x0b, 5 ; 11
d6c: fe cf rjmp .-4 ; 0xd6a <__stack+0x90b>
UDR = c;
d6e: 8b e3 ldi r24, 0x3B ; 59
d70: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
d72: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
d74: bb 9a sbi 0x17, 3 ; 23
d76: e3 e8 ldi r30, 0x83 ; 131
d78: f1 e0 ldi r31, 0x01 ; 1
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
d7a: 8d e6 ldi r24, 0x6D ; 109
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
d7c: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
d7e: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
d80: 5d 9b sbis 0x0b, 5 ; 11
d82: fe cf rjmp .-4 ; 0xd80 <__stack+0x921>
UDR = c;
d84: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
d86: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
d88: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
d8a: 81 91 ld r24, Z+
d8c: 81 11 cpse r24, r1
d8e: f6 cf rjmp .-20 ; 0xd7c <__stack+0x91d>
r.send("v1="); r.send(utoa(v1, vs, 10)); r.send(";");
char cs[11]; r.send("cm="); r.send(dtostrf(tm, 10, 2, cs)); r.send(";");
r.send("c0="); r.send(dtostrf(t0, 10, 2, cs)); r.send(";");
r.send("c1="); r.send(dtostrf(t1, 10, 2, cs)); r.send(";");
char ts[11]; r.send("t="); r.send(utoa(target_temp, ts, 10)); r.send(";");
char ms[11]; r.send("m="); r.send(utoa(target_motor, ms, 10)); r.send(";");
d90: 4a e0 ldi r20, 0x0A ; 10
d92: 50 e0 ldi r21, 0x00 ; 0
d94: be 01 movw r22, r28
d96: 6f 5a subi r22, 0xAF ; 175
d98: 7f 4f sbci r23, 0xFF ; 255
d9a: ca 56 subi r28, 0x6A ; 106
d9c: df 4f sbci r29, 0xFF ; 255
d9e: f8 81 ld r31, Y
da0: c6 59 subi r28, 0x96 ; 150
da2: d0 40 sbci r29, 0x00 ; 0
da4: 8f 2f mov r24, r31
da6: 99 27 eor r25, r25
da8: 87 fd sbrc r24, 7
daa: 90 95 com r25
dac: 0e 94 47 0b call 0x168e ; 0x168e <utoa>
db0: dc 01 movw r26, r24
db2: 2c 91 ld r18, X
db4: 22 23 and r18, r18
db6: 61 f0 breq .+24 ; 0xdd0 <__stack+0x971>
l.off(l.YELLOW);
r.send("#### End Bootup ###########################################\n");
l.on(l.GREEN);
}
int main(void)
db8: fc 01 movw r30, r24
dba: 31 96 adiw r30, 0x01 ; 1
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
dbc: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
dbe: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
dc0: 5d 9b sbis 0x0b, 5 ; 11
dc2: fe cf rjmp .-4 ; 0xdc0 <__stack+0x961>
UDR = c;
dc4: 2c b9 out 0x0c, r18 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
dc6: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
dc8: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
dca: 21 91 ld r18, Z+
dcc: 21 11 cpse r18, r1
dce: f6 cf rjmp .-20 ; 0xdbc <__stack+0x95d>
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
dd0: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
dd2: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
dd4: 5d 9b sbis 0x0b, 5 ; 11
dd6: fe cf rjmp .-4 ; 0xdd4 <__stack+0x975>
UDR = c;
dd8: 8b e3 ldi r24, 0x3B ; 59
dda: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
ddc: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
dde: bb 9a sbi 0x17, 3 ; 23
char cs[11]; r.send("cm="); r.send(dtostrf(tm, 10, 2, cs)); r.send(";");
r.send("c0="); r.send(dtostrf(t0, 10, 2, cs)); r.send(";");
r.send("c1="); r.send(dtostrf(t1, 10, 2, cs)); r.send(";");
char ts[11]; r.send("t="); r.send(utoa(target_temp, ts, 10)); r.send(";");
char ms[11]; r.send("m="); r.send(utoa(target_motor, ms, 10)); r.send(";");
r.send((o.isOn(o.OUT1)==1)?"hon=1;":"hon=0;");
de0: 9a 9b sbis 0x13, 2 ; 19
de2: 03 c0 rjmp .+6 ; 0xdea <__stack+0x98b>
de4: e2 e6 ldi r30, 0x62 ; 98
de6: f1 e0 ldi r31, 0x01 ; 1
de8: 02 c0 rjmp .+4 ; 0xdee <__stack+0x98f>
dea: eb e5 ldi r30, 0x5B ; 91
dec: f1 e0 ldi r31, 0x01 ; 1
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
dee: 80 81 ld r24, Z
df0: 88 23 and r24, r24
df2: 59 f0 breq .+22 ; 0xe0a <__stack+0x9ab>
l.off(l.YELLOW);
r.send("#### End Bootup ###########################################\n");
l.on(l.GREEN);
}
int main(void)
df4: 31 96 adiw r30, 0x01 ; 1
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
df6: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
df8: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
dfa: 5d 9b sbis 0x0b, 5 ; 11
dfc: fe cf rjmp .-4 ; 0xdfa <__stack+0x99b>
UDR = c;
dfe: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
e00: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
e02: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
e04: 81 91 ld r24, Z+
e06: 81 11 cpse r24, r1
e08: f6 cf rjmp .-20 ; 0xdf6 <__stack+0x997>
r.send("c0="); r.send(dtostrf(t0, 10, 2, cs)); r.send(";");
r.send("c1="); r.send(dtostrf(t1, 10, 2, cs)); r.send(";");
char ts[11]; r.send("t="); r.send(utoa(target_temp, ts, 10)); r.send(";");
char ms[11]; r.send("m="); r.send(utoa(target_motor, ms, 10)); r.send(";");
r.send((o.isOn(o.OUT1)==1)?"hon=1;":"hon=0;");
r.send((o.isOn(o.OUT2)==1)?"mon=1":"mon=0");
e0a: 9b 9b sbis 0x13, 3 ; 19
e0c: 03 c0 rjmp .+6 ; 0xe14 <__stack+0x9b5>
e0e: ef e6 ldi r30, 0x6F ; 111
e10: f1 e0 ldi r31, 0x01 ; 1
e12: 02 c0 rjmp .+4 ; 0xe18 <__stack+0x9b9>
e14: e9 e6 ldi r30, 0x69 ; 105
e16: f1 e0 ldi r31, 0x01 ; 1
e18: 80 81 ld r24, Z
e1a: 88 23 and r24, r24
e1c: 59 f0 breq .+22 ; 0xe34 <__stack+0x9d5>
l.off(l.YELLOW);
r.send("#### End Bootup ###########################################\n");
l.on(l.GREEN);
}
int main(void)
e1e: 31 96 adiw r30, 0x01 ; 1
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
e20: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
e22: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
e24: 5d 9b sbis 0x0b, 5 ; 11
e26: fe cf rjmp .-4 ; 0xe24 <__stack+0x9c5>
UDR = c;
e28: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
e2a: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
e2c: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
e2e: 81 91 ld r24, Z+
e30: 81 11 cpse r24, r1
e32: f6 cf rjmp .-20 ; 0xe20 <__stack+0x9c1>
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
e34: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
e36: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
e38: 5d 9b sbis 0x0b, 5 ; 11
e3a: fe cf rjmp .-4 ; 0xe38 <__stack+0x9d9>
UDR = c;
e3c: 8a e0 ldi r24, 0x0A ; 10
e3e: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
e40: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
e42: bb 9a sbi 0x17, 3 ; 23
#else
//round up by default
__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
#endif
__builtin_avr_delay_cycles(__ticks_dc);
e44: bf ef ldi r27, 0xFF ; 255
e46: e0 e7 ldi r30, 0x70 ; 112
e48: f2 e0 ldi r31, 0x02 ; 2
e4a: b1 50 subi r27, 0x01 ; 1
e4c: e0 40 sbci r30, 0x00 ; 0
e4e: f0 40 sbci r31, 0x00 ; 0
e50: e1 f7 brne .-8 ; 0xe4a <__stack+0x9eb>
e52: 00 c0 rjmp .+0 ; 0xe54 <__stack+0x9f5>
e54: 00 00 nop
int8_t target_motor = 20;
float pwm_value = 0;
uint16_t v0a[20] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint16_t v1a[20] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint8_t p = 0;
while(1)
e56: fc ca rjmp .-2568 ; 0x450 <main+0x96>
if(ausg < 0)
ausg = 0;
if(ausg > 5)
ausg = 5;
if(val < 0)
val = 0;
e58: 41 2c mov r4, r1
e5a: 51 2c mov r5, r1
e5c: c6 57 subi r28, 0x76 ; 118
e5e: df 4f sbci r29, 0xFF ; 255
e60: 18 82 st Y, r1
e62: ca 58 subi r28, 0x8A ; 138
e64: d0 40 sbci r29, 0x00 ; 0
e66: c5 57 subi r28, 0x75 ; 117
e68: df 4f sbci r29, 0xFF ; 255
e6a: 18 82 st Y, r1
e6c: cb 58 subi r28, 0x8B ; 139
e6e: d0 40 sbci r29, 0x00 ; 0
e70: 0e c0 rjmp .+28 ; 0xe8e <__stack+0xa2f>
if(val > 20)
val = 20;
e72: 41 2c mov r4, r1
e74: 51 2c mov r5, r1
e76: 20 ea ldi r18, 0xA0 ; 160
e78: c6 57 subi r28, 0x76 ; 118
e7a: df 4f sbci r29, 0xFF ; 255
e7c: 28 83 st Y, r18
e7e: ca 58 subi r28, 0x8A ; 138
e80: d0 40 sbci r29, 0x00 ; 0
e82: 31 e4 ldi r19, 0x41 ; 65
e84: c5 57 subi r28, 0x75 ; 117
e86: df 4f sbci r29, 0xFF ; 255
e88: 38 83 st Y, r19
e8a: cb 58 subi r28, 0x8B ; 139
e8c: d0 40 sbci r29, 0x00 ; 0
this->pwm[ausg] = (uint8_t)val;
e8e: c6 57 subi r28, 0x76 ; 118
e90: df 4f sbci r29, 0xFF ; 255
e92: 38 81 ld r19, Y
e94: ca 58 subi r28, 0x8A ; 138
e96: d0 40 sbci r29, 0x00 ; 0
e98: c5 57 subi r28, 0x75 ; 117
e9a: df 4f sbci r29, 0xFF ; 255
e9c: 28 81 ld r18, Y
e9e: cb 58 subi r28, 0x8B ; 139
ea0: d0 40 sbci r29, 0x00 ; 0
ea2: 64 2d mov r22, r4
ea4: 75 2d mov r23, r5
ea6: 83 2f mov r24, r19
ea8: 92 2f mov r25, r18
eaa: 0e 94 a7 09 call 0x134e ; 0x134e <__fixunssfsi>
eae: 60 93 df 01 sts 0x01DF, r22
eb2: e1 e9 ldi r30, 0x91 ; 145
eb4: f1 e0 ldi r31, 0x01 ; 1
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
eb6: 80 e7 ldi r24, 0x70 ; 112
eb8: a4 cd rjmp .-1208 ; 0xa02 <__stack+0x5a3>
00000eba <__vector_6>:
r.send("\n");
_delay_ms(50);
}
}
ISR(TIMER1_COMPA_vect) {
eba: 1f 92 push r1
ebc: 0f 92 push r0
ebe: 0f b6 in r0, 0x3f ; 63
ec0: 0f 92 push r0
ec2: 11 24 eor r1, r1
ec4: 2f 93 push r18
ec6: 3f 93 push r19
ec8: 4f 93 push r20
eca: 5f 93 push r21
ecc: 6f 93 push r22
ece: 7f 93 push r23
ed0: 8f 93 push r24
ed2: 9f 93 push r25
ed4: af 93 push r26
ed6: bf 93 push r27
ed8: ef 93 push r30
eda: ff 93 push r31
if(ausg > 5)
ausg = 5;
return this->pwm[ausg];
}
void timer() {
if (this->pct++ >= 20) {
edc: 80 91 dd 01 lds r24, 0x01DD
ee0: 84 31 cpi r24, 0x14 ; 20
ee2: 08 f4 brcc .+2 ; 0xee6 <__vector_6+0x2c>
ee4: 51 c0 rjmp .+162 ; 0xf88 <__vector_6+0xce>
this->pct=0;
ee6: 10 92 dd 01 sts 0x01DD, r1
eea: 51 c0 rjmp .+162 ; 0xf8e <__vector_6+0xd4>
}
for(uint8_t i = 0; i < 6; i++) {
if(this->pwm[i] >= this->pct && this->pwm[i] != 0) {
eec: 82 2f mov r24, r18
eee: 91 91 ld r25, Z+
ef0: 6c 91 ld r22, X
ef2: 96 17 cp r25, r22
ef4: 18 f1 brcs .+70 ; 0xf3c <__vector_6+0x82>
ef6: 99 23 and r25, r25
ef8: 09 f1 breq .+66 ; 0xf3c <__vector_6+0x82>
this->on((1<<i));
efa: ba 01 movw r22, r20
efc: 02 2e mov r0, r18
efe: 02 c0 rjmp .+4 ; 0xf04 <__vector_6+0x4a>
f00: 66 0f add r22, r22
f02: 77 1f adc r23, r23
f04: 0a 94 dec r0
f06: e2 f7 brpl .-8 ; 0xf00 <__vector_6+0x46>
f08: cb 01 movw r24, r22
if(ausg & OUT6) {
out6::make_low();
}
}
void on(uint8_t ausg = 255) {
if(ausg & OUT1) {
f0a: 60 ff sbrs r22, 0
f0c: 02 c0 rjmp .+4 ; 0xf12 <__vector_6+0x58>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
f0e: aa 9a sbi 0x15, 2 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
f10: a2 9a sbi 0x14, 2 ; 20
out1::make_high();
}
if(ausg & OUT2) {
f12: 81 ff sbrs r24, 1
f14: 02 c0 rjmp .+4 ; 0xf1a <__vector_6+0x60>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
f16: ab 9a sbi 0x15, 3 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
f18: a3 9a sbi 0x14, 3 ; 20
out2::make_high();
}
if(ausg & OUT3) {
f1a: 82 ff sbrs r24, 2
f1c: 02 c0 rjmp .+4 ; 0xf22 <__vector_6+0x68>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
f1e: ac 9a sbi 0x15, 4 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
f20: a4 9a sbi 0x14, 4 ; 20
out3::make_high();
}
if(ausg & OUT4) {
f22: 83 ff sbrs r24, 3
f24: 02 c0 rjmp .+4 ; 0xf2a <__vector_6+0x70>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
f26: ad 9a sbi 0x15, 5 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
f28: a5 9a sbi 0x14, 5 ; 20
out4::make_high();
}
if(ausg & OUT5) {
f2a: 84 ff sbrs r24, 4
f2c: 02 c0 rjmp .+4 ; 0xf32 <__vector_6+0x78>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
f2e: ae 9a sbi 0x15, 6 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
f30: a6 9a sbi 0x14, 6 ; 20
out5::make_high();
}
if(ausg & OUT6) {
f32: 85 ff sbrs r24, 5
f34: 22 c0 rjmp .+68 ; 0xf7a <__vector_6+0xc0>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
f36: af 9a sbi 0x15, 7 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
f38: a7 9a sbi 0x14, 7 ; 20
f3a: 1f c0 rjmp .+62 ; 0xf7a <__vector_6+0xc0>
}
for(uint8_t i = 0; i < 6; i++) {
if(this->pwm[i] >= this->pct && this->pwm[i] != 0) {
this->on((1<<i));
} else {
this->off((1<<i));
f3c: ba 01 movw r22, r20
f3e: 02 c0 rjmp .+4 ; 0xf44 <__vector_6+0x8a>
f40: 66 0f add r22, r22
f42: 77 1f adc r23, r23
f44: 8a 95 dec r24
f46: e2 f7 brpl .-8 ; 0xf40 <__vector_6+0x86>
f48: cb 01 movw r24, r22
public:
SSR() {
init();
}
void off(uint8_t ausg = 255) {
if(ausg & OUT1) {
f4a: 60 ff sbrs r22, 0
f4c: 02 c0 rjmp .+4 ; 0xf52 <__vector_6+0x98>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
f4e: aa 98 cbi 0x15, 2 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
f50: a2 9a sbi 0x14, 2 ; 20
out1::make_low();
}
if(ausg & OUT2) {
f52: 81 ff sbrs r24, 1
f54: 02 c0 rjmp .+4 ; 0xf5a <__vector_6+0xa0>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
f56: ab 98 cbi 0x15, 3 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
f58: a3 9a sbi 0x14, 3 ; 20
out2::make_low();
}
if(ausg & OUT3) {
f5a: 82 ff sbrs r24, 2
f5c: 02 c0 rjmp .+4 ; 0xf62 <__vector_6+0xa8>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
f5e: ac 98 cbi 0x15, 4 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
f60: a4 9a sbi 0x14, 4 ; 20
out3::make_low();
}
if(ausg & OUT4) {
f62: 83 ff sbrs r24, 3
f64: 02 c0 rjmp .+4 ; 0xf6a <__vector_6+0xb0>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
f66: ad 98 cbi 0x15, 5 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
f68: a5 9a sbi 0x14, 5 ; 20
out4::make_low();
}
if(ausg & OUT5) {
f6a: 84 ff sbrs r24, 4
f6c: 02 c0 rjmp .+4 ; 0xf72 <__vector_6+0xb8>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
f6e: ae 98 cbi 0x15, 6 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
f70: a6 9a sbi 0x14, 6 ; 20
out5::make_low();
}
if(ausg & OUT6) {
f72: 85 ff sbrs r24, 5
f74: 02 c0 rjmp .+4 ; 0xf7a <__vector_6+0xc0>
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
f76: af 98 cbi 0x15, 7 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
f78: a7 9a sbi 0x14, 7 ; 20
f7a: 2f 5f subi r18, 0xFF ; 255
f7c: 3f 4f sbci r19, 0xFF ; 255
}
void timer() {
if (this->pct++ >= 20) {
this->pct=0;
}
for(uint8_t i = 0; i < 6; i++) {
f7e: 26 30 cpi r18, 0x06 ; 6
f80: 31 05 cpc r19, r1
f82: 09 f0 breq .+2 ; 0xf86 <__vector_6+0xcc>
f84: b3 cf rjmp .-154 ; 0xeec <__vector_6+0x32>
f86: 0c c0 rjmp .+24 ; 0xfa0 <__vector_6+0xe6>
if(ausg > 5)
ausg = 5;
return this->pwm[ausg];
}
void timer() {
if (this->pct++ >= 20) {
f88: 8f 5f subi r24, 0xFF ; 255
f8a: 80 93 dd 01 sts 0x01DD, r24
f8e: ee ed ldi r30, 0xDE ; 222
f90: f1 e0 ldi r31, 0x01 ; 1
f92: 20 e0 ldi r18, 0x00 ; 0
f94: 30 e0 ldi r19, 0x00 ; 0
this->pct=0;
}
for(uint8_t i = 0; i < 6; i++) {
if(this->pwm[i] >= this->pct && this->pwm[i] != 0) {
f96: ad ed ldi r26, 0xDD ; 221
f98: b1 e0 ldi r27, 0x01 ; 1
this->on((1<<i));
} else {
this->off((1<<i));
f9a: 41 e0 ldi r20, 0x01 ; 1
f9c: 50 e0 ldi r21, 0x00 ; 0
f9e: a6 cf rjmp .-180 ; 0xeec <__vector_6+0x32>
o.timer();
}
fa0: ff 91 pop r31
fa2: ef 91 pop r30
fa4: bf 91 pop r27
fa6: af 91 pop r26
fa8: 9f 91 pop r25
faa: 8f 91 pop r24
fac: 7f 91 pop r23
fae: 6f 91 pop r22
fb0: 5f 91 pop r21
fb2: 4f 91 pop r20
fb4: 3f 91 pop r19
fb6: 2f 91 pop r18
fb8: 0f 90 pop r0
fba: 0f be out 0x3f, r0 ; 63
fbc: 0f 90 pop r0
fbe: 1f 90 pop r1
fc0: 18 95 reti
00000fc2 <__vector_1>:
ISR(INT0_vect) {
fc2: 1f 92 push r1
fc4: 0f 92 push r0
fc6: 0f b6 in r0, 0x3f ; 63
fc8: 0f 92 push r0
fca: 11 24 eor r1, r1
fcc: 8f 93 push r24
}
void intr() {
GIFR = (1<<INTF0);
fce: 80 e4 ldi r24, 0x40 ; 64
fd0: 8a bf out 0x3a, r24 ; 58
b.intr();
}
fd2: 8f 91 pop r24
fd4: 0f 90 pop r0
fd6: 0f be out 0x3f, r0 ; 63
fd8: 0f 90 pop r0
fda: 1f 90 pop r1
fdc: 18 95 reti
00000fde <__vector_11>:
ISR(USART_RXC_vect) {
fde: 1f 92 push r1
fe0: 0f 92 push r0
fe2: 0f b6 in r0, 0x3f ; 63
fe4: 0f 92 push r0
fe6: 11 24 eor r1, r1
fe8: 2f 93 push r18
fea: 3f 93 push r19
fec: 4f 93 push r20
fee: 8f 93 push r24
ff0: 9f 93 push r25
ff2: ef 93 push r30
ff4: ff 93 push r31
int8_t m = this->motor;
this->motor = -1;
return m;
}
void intr() {
uint8_t nextChar = UDR;
ff6: 8c b1 in r24, 0x0c ; 12
//uart_putchar(nextChar);
if( nextChar != '\n' && nextChar != '\r' && this->uart_str_count < this->UART_MAXSTRLEN ) {
ff8: 8a 30 cpi r24, 0x0A ; 10
ffa: 79 f0 breq .+30 ; 0x101a <__vector_11+0x3c>
ffc: 8d 30 cpi r24, 0x0D ; 13
ffe: 69 f0 breq .+26 ; 0x101a <__vector_11+0x3c>
1000: 90 91 d7 01 lds r25, 0x01D7
1004: 95 30 cpi r25, 0x05 ; 5
1006: 48 f4 brcc .+18 ; 0x101a <__vector_11+0x3c>
this->uart_string[this->uart_str_count] = nextChar;
1008: e9 2f mov r30, r25
100a: f0 e0 ldi r31, 0x00 ; 0
100c: ed 52 subi r30, 0x2D ; 45
100e: fe 4f sbci r31, 0xFE ; 254
1010: 85 83 std Z+5, r24 ; 0x05
this->uart_str_count++;
1012: 9f 5f subi r25, 0xFF ; 255
1014: 90 93 d7 01 sts 0x01D7, r25
1018: 33 c0 rjmp .+102 ; 0x1080 <__vector_11+0xa2>
} else {
if(this->uart_string[0] == 't') {
101a: 80 91 d8 01 lds r24, 0x01D8
101e: 84 37 cpi r24, 0x74 ; 116
1020: f1 f4 brne .+60 ; 0x105e <__vector_11+0x80>
this->temp = (this->uart_string[1]-48)*100+(this->uart_string[2]-48)*10+(this->uart_string[3]-48);
1022: 40 91 d9 01 lds r20, 0x01D9
1026: 80 91 da 01 lds r24, 0x01DA
102a: 90 e0 ldi r25, 0x00 ; 0
102c: 88 0f add r24, r24
102e: 99 1f adc r25, r25
1030: 9c 01 movw r18, r24
1032: 22 0f add r18, r18
1034: 33 1f adc r19, r19
1036: 22 0f add r18, r18
1038: 33 1f adc r19, r19
103a: 82 0f add r24, r18
103c: 93 1f adc r25, r19
103e: 24 e6 ldi r18, 0x64 ; 100
1040: 42 9f mul r20, r18
1042: 80 0d add r24, r0
1044: 91 1d adc r25, r1
1046: 11 24 eor r1, r1
1048: 20 91 db 01 lds r18, 0x01DB
104c: 82 0f add r24, r18
104e: 91 1d adc r25, r1
1050: 80 5d subi r24, 0xD0 ; 208
1052: 94 41 sbci r25, 0x14 ; 20
1054: 90 93 d5 01 sts 0x01D5, r25
1058: 80 93 d4 01 sts 0x01D4, r24
105c: 0f c0 rjmp .+30 ; 0x107c <__vector_11+0x9e>
}
if(uart_string[0] == 'm') {
105e: 8d 36 cpi r24, 0x6D ; 109
1060: 69 f4 brne .+26 ; 0x107c <__vector_11+0x9e>
this->motor = (this->uart_string[1]-48)*10+(this->uart_string[2]-48);
1062: 90 91 da 01 lds r25, 0x01DA
1066: 90 51 subi r25, 0x10 ; 16
1068: 80 91 d9 01 lds r24, 0x01D9
106c: 88 0f add r24, r24
106e: 28 2f mov r18, r24
1070: 22 0f add r18, r18
1072: 22 0f add r18, r18
1074: 82 0f add r24, r18
1076: 89 0f add r24, r25
1078: 80 93 d6 01 sts 0x01D6, r24
}
this->uart_str_count = 0;
107c: 10 92 d7 01 sts 0x01D7, r1
r.intr();
1080: ff 91 pop r31
1082: ef 91 pop r30
1084: 9f 91 pop r25
1086: 8f 91 pop r24
1088: 4f 91 pop r20
108a: 3f 91 pop r19
108c: 2f 91 pop r18
108e: 0f 90 pop r0
1090: 0f be out 0x3f, r0 ; 63
1092: 0f 90 pop r0
1094: 1f 90 pop r1
1096: 18 95 reti
00001098 <_ZN3SSRIN6avrlib5portcELi2ELi3ELi4ELi5ELi6ELi7EEC1Ev>:
#include "hardware/pin.hpp"
template <typename Port, int pin_out1, int pin_out2, int pin_out3, int pin_out4, int pin_out5, int pin_out6>
class SSR {
public:
SSR() {
1098: fc 01 movw r30, r24
109a: 11 92 st Z+, r1
109c: 86 e0 ldi r24, 0x06 ; 6
109e: df 01 movw r26, r30
10a0: 1d 92 st X+, r1
10a2: 8a 95 dec r24
10a4: e9 f7 brne .-6 ; 0x10a0 <_ZN3SSRIN6avrlib5portcELi2ELi3ELi4ELi5ELi6ELi7EEC1Ev+0x8>
10a6: a2 9a sbi 0x14, 2 ; 20
10a8: a3 9a sbi 0x14, 3 ; 20
10aa: a4 9a sbi 0x14, 4 ; 20
10ac: a5 9a sbi 0x14, 5 ; 20
10ae: a6 9a sbi 0x14, 6 ; 20
10b0: a7 9a sbi 0x14, 7 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
10b2: aa 98 cbi 0x15, 2 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
10b4: a2 9a sbi 0x14, 2 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
10b6: ab 98 cbi 0x15, 3 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
10b8: a3 9a sbi 0x14, 3 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
10ba: ac 98 cbi 0x15, 4 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
10bc: a4 9a sbi 0x14, 4 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
10be: ad 98 cbi 0x15, 5 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
10c0: a5 9a sbi 0x14, 5 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
10c2: ae 98 cbi 0x15, 6 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
10c4: a6 9a sbi 0x14, 6 ; 20
namespace avrlib {
struct portc
{
static uint8_t port() { return PORTC; }
static void port(uint8_t v) { PORTC = v; }
10c6: af 98 cbi 0x15, 7 ; 21
static uint8_t pin() { return PINC; }
static void pin(uint8_t v) { PINC = v; }
static uint8_t dir() { return DDRC; }
static void dir(uint8_t v) { DDRC = v; }
10c8: a7 9a sbi 0x14, 7 ; 20
10ca: 08 95 ret
000010cc <_ZN5UsartILm38400EN6avrlib5portdELi5ELi4ELi3EEC1E3LedINS0_5portbELi4ELi3ELi2EE>:
#define USART_H_
template <uint32_t baudrate, typename RSPort, int pin_rts, int pin_cts, int pin_pwren>
class Usart {
public:
Usart(ledclass l) {
10cc: cf 93 push r28
10ce: df 93 push r29
10d0: 1f 92 push r1
10d2: cd b7 in r28, 0x3d ; 61
10d4: de b7 in r29, 0x3e ; 62
10d6: fc 01 movw r30, r24
10d8: 69 83 std Y+1, r22 ; 0x01
10da: bc 9a sbi 0x17, 4 ; 23
10dc: bb 9a sbi 0x17, 3 ; 23
10de: ba 9a sbi 0x17, 2 ; 23
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
10e0: c4 98 cbi 0x18, 4 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
10e2: bc 9a sbi 0x17, 4 ; 23
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
10e4: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
10e6: bb 9a sbi 0x17, 3 ; 23
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
10e8: c2 98 cbi 0x18, 2 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
10ea: ba 9a sbi 0x17, 2 ; 23
10ec: 8f ef ldi r24, 0xFF ; 255
10ee: 9f ef ldi r25, 0xFF ; 255
10f0: 92 83 std Z+2, r25 ; 0x02
10f2: 81 83 std Z+1, r24 ; 0x01
10f4: 8f ef ldi r24, 0xFF ; 255
10f6: 83 83 std Z+3, r24 ; 0x03
10f8: 14 82 std Z+4, r1 ; 0x04
this->uart_str_count = 0;
}
}
private:
void init() {
UCSRA = 0;
10fa: 1b b8 out 0x0b, r1 ; 11
UCSRB = (1<<TXEN) | (1<<RXEN) | (1<<RXCIE);
10fc: 88 e9 ldi r24, 0x98 ; 152
10fe: 8a b9 out 0x0a, r24 ; 10
UCSRC = (1<<URSEL) | (1<<UPM1) | (1<<UCSZ1) | (1<<UCSZ0); //8E1
1100: 86 ea ldi r24, 0xA6 ; 166
1102: 80 bd out 0x20, r24 ; 32
UBRRH = 0;
1104: 10 bc out 0x20, r1 ; 32
UBRRL = (F_CPU / (baudrate * 16L) - 1);
1106: 89 e1 ldi r24, 0x19 ; 25
1108: 89 b9 out 0x09, r24 ; 9
sei();
110a: 78 94 sei
110c: e6 e9 ldi r30, 0x96 ; 150
110e: f1 e0 ldi r31, 0x01 ; 1
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
1110: 85 e5 ldi r24, 0x55 ; 85
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
1112: c3 9a sbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
1114: bb 9a sbi 0x17, 3 ; 23
UBRRL = (F_CPU / (baudrate * 16L) - 1);
sei();
}
uint8_t uart_putchar(uint8_t c) {
led.on(led.YELLOW);
loop_until_bit_is_set(UCSRA, UDRE); //Ausgabe des Zeichens
1116: 5d 9b sbis 0x0b, 5 ; 11
1118: fe cf rjmp .-4 ; 0x1116 <_ZN5UsartILm38400EN6avrlib5portdELi5ELi4ELi3EEC1E3LedINS0_5portbELi4ELi3ELi2EE+0x4a>
UDR = c;
111a: 8c b9 out 0x0c, r24 ; 12
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
111c: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
111e: bb 9a sbi 0x17, 3 ; 23
init();
this->led = l;
send("Uart done!\n");
}
void send(const char *text) {
while (*text)
1120: 81 91 ld r24, Z+
1122: 81 11 cpse r24, r1
1124: f6 cf rjmp .-20 ; 0x1112 <_ZN5UsartILm38400EN6avrlib5portdELi5ELi4ELi3EEC1E3LedINS0_5portbELi4ELi3ELi2EE+0x46>
public:
Usart(ledclass l) {
init();
this->led = l;
send("Uart done!\n");
}
1126: 0f 90 pop r0
1128: df 91 pop r29
112a: cf 91 pop r28
112c: 08 95 ret
0000112e <_ZN6ButtonIN6avrlib5portdELi2EEC1E3LedINS0_5portbELi4ELi3ELi2EE>:
template <typename BPort, int pin_bt1>
class Button {
public:
Button(ledclass l) {
112e: cf 93 push r28
1130: df 93 push r29
1132: 1f 92 push r1
1134: cd b7 in r28, 0x3d ; 61
1136: de b7 in r29, 0x3e ; 62
1138: 69 83 std Y+1, r22 ; 0x01
113a: bc 9a sbi 0x17, 4 ; 23
113c: bb 9a sbi 0x17, 3 ; 23
113e: ba 9a sbi 0x17, 2 ; 23
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
1140: c4 98 cbi 0x18, 4 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
1142: bc 9a sbi 0x17, 4 ; 23
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
1144: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
1146: bb 9a sbi 0x17, 3 ; 23
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
1148: c2 98 cbi 0x18, 2 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
114a: ba 9a sbi 0x17, 2 ; 23
static uint8_t pin() { return PIND; }
static void pin(uint8_t v) { PIND = v; }
static uint8_t dir() { return DDRD; }
static void dir(uint8_t v) { DDRD = v; }
114c: 8a 98 cbi 0x11, 2 ; 17
namespace avrlib {
struct portd
{
static uint8_t port() { return PORTD; }
static void port(uint8_t v) { PORTD = v; }
114e: 92 98 cbi 0x12, 2 ; 18
1150: 92 9a sbi 0x12, 2 ; 18
init();
this->led = l;
}
1152: 0f 90 pop r0
1154: df 91 pop r29
1156: cf 91 pop r28
1158: 08 95 ret
0000115a <_ZN3LedIN6avrlib5portbELi4ELi3ELi2EE4initEv>:
115a: bc 9a sbi 0x17, 4 ; 23
115c: bb 9a sbi 0x17, 3 ; 23
115e: ba 9a sbi 0x17, 2 ; 23
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
1160: c4 98 cbi 0x18, 4 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
1162: bc 9a sbi 0x17, 4 ; 23
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
1164: c3 98 cbi 0x18, 3 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
1166: bb 9a sbi 0x17, 3 ; 23
namespace avrlib {
struct portb
{
static uint8_t port() { return PORTB; }
static void port(uint8_t v) { PORTB = v; }
1168: c2 98 cbi 0x18, 2 ; 24
static uint8_t pin() { return PINB; }
static void pin(uint8_t v) { PINB = v; }
static uint8_t dir() { return DDRB; }
static void dir(uint8_t v) { DDRB = v; }
116a: ba 9a sbi 0x17, 2 ; 23
116c: 08 95 ret
0000116e <_GLOBAL__sub_I_l>:
template <typename Port, int pin_red, int pin_yellow, int pin_green>
class Led {
public:
Led() {
init();
116e: 84 ee ldi r24, 0xE4 ; 228
1170: 91 e0 ldi r25, 0x01 ; 1
1172: 0e 94 ad 08 call 0x115a ; 0x115a <_ZN3LedIN6avrlib5portbELi4ELi3ELi2EE4initEv>
#include "peripheral.h"
#include <stdlib.h>
ledclass l;
ssrclass o;
1176: 8d ed ldi r24, 0xDD ; 221
1178: 91 e0 ldi r25, 0x01 ; 1
117a: 0e 94 4c 08 call 0x1098 ; 0x1098 <_ZN3SSRIN6avrlib5portcELi2ELi3ELi4ELi5ELi6ELi7EEC1Ev>
usartclass r(l);
117e: 60 e0 ldi r22, 0x00 ; 0
1180: 83 ed ldi r24, 0xD3 ; 211
1182: 91 e0 ldi r25, 0x01 ; 1
1184: 0e 94 66 08 call 0x10cc ; 0x10cc <_ZN5UsartILm38400EN6avrlib5portdELi5ELi4ELi3EEC1E3LedINS0_5portbELi4ELi3ELi2EE>
#include <util/delay.h>
template <bool avcc>
class Adc {
public:
Adc() {
1188: 80 e3 ldi r24, 0x30 ; 48
118a: e0 e6 ldi r30, 0x60 ; 96
118c: f0 e0 ldi r31, 0x00 ; 0
118e: a3 ea ldi r26, 0xA3 ; 163
1190: b1 e0 ldi r27, 0x01 ; 1
1192: 01 90 ld r0, Z+
1194: 0d 92 st X+, r0
1196: 8a 95 dec r24
1198: e1 f7 brne .-8 ; 0x1192 <_GLOBAL__sub_I_l+0x24>
return (m * (float)v) + (-m * v1) + c1;
}
private:
void init() {
ADCSRA = (1<<ADPS2);
119a: 84 e0 ldi r24, 0x04 ; 4
119c: 86 b9 out 0x06, r24 ; 6
if(avcc) {
ADMUX = (1<<REFS0);
} else {
ADMUX = 0;
119e: 17 b8 out 0x07, r1 ; 7
adcclass a;
buttonclass b(l);
11a0: 60 e0 ldi r22, 0x00 ; 0
11a2: 82 ea ldi r24, 0xA2 ; 162
11a4: 91 e0 ldi r25, 0x01 ; 1
11a6: 0e 94 97 08 call 0x112e ; 0x112e <_ZN6ButtonIN6avrlib5portdELi2EEC1E3LedINS0_5portbELi4ELi3ELi2EE>
11aa: 08 95 ret
000011ac <__subsf3>:
11ac: 50 58 subi r21, 0x80 ; 128
000011ae <__addsf3>:
11ae: bb 27 eor r27, r27
11b0: aa 27 eor r26, r26
11b2: 0e d0 rcall .+28 ; 0x11d0 <__addsf3x>
11b4: 70 c1 rjmp .+736 ; 0x1496 <__fp_round>
11b6: 61 d1 rcall .+706 ; 0x147a <__fp_pscA>
11b8: 30 f0 brcs .+12 ; 0x11c6 <__addsf3+0x18>
11ba: 66 d1 rcall .+716 ; 0x1488 <__fp_pscB>
11bc: 20 f0 brcs .+8 ; 0x11c6 <__addsf3+0x18>
11be: 31 f4 brne .+12 ; 0x11cc <__addsf3+0x1e>
11c0: 9f 3f cpi r25, 0xFF ; 255
11c2: 11 f4 brne .+4 ; 0x11c8 <__addsf3+0x1a>
11c4: 1e f4 brtc .+6 ; 0x11cc <__addsf3+0x1e>
11c6: 56 c1 rjmp .+684 ; 0x1474 <__fp_nan>
11c8: 0e f4 brtc .+2 ; 0x11cc <__addsf3+0x1e>
11ca: e0 95 com r30
11cc: e7 fb bst r30, 7
11ce: 4c c1 rjmp .+664 ; 0x1468 <__fp_inf>
000011d0 <__addsf3x>:
11d0: e9 2f mov r30, r25
11d2: 72 d1 rcall .+740 ; 0x14b8 <__fp_split3>
11d4: 80 f3 brcs .-32 ; 0x11b6 <__addsf3+0x8>
11d6: ba 17 cp r27, r26
11d8: 62 07 cpc r22, r18
11da: 73 07 cpc r23, r19
11dc: 84 07 cpc r24, r20
11de: 95 07 cpc r25, r21
11e0: 18 f0 brcs .+6 ; 0x11e8 <__addsf3x+0x18>
11e2: 71 f4 brne .+28 ; 0x1200 <__addsf3x+0x30>
11e4: 9e f5 brtc .+102 ; 0x124c <__addsf3x+0x7c>
11e6: 8a c1 rjmp .+788 ; 0x14fc <__fp_zero>
11e8: 0e f4 brtc .+2 ; 0x11ec <__addsf3x+0x1c>
11ea: e0 95 com r30
11ec: 0b 2e mov r0, r27
11ee: ba 2f mov r27, r26
11f0: a0 2d mov r26, r0
11f2: 0b 01 movw r0, r22
11f4: b9 01 movw r22, r18
11f6: 90 01 movw r18, r0
11f8: 0c 01 movw r0, r24
11fa: ca 01 movw r24, r20
11fc: a0 01 movw r20, r0
11fe: 11 24 eor r1, r1
1200: ff 27 eor r31, r31
1202: 59 1b sub r21, r25
1204: 99 f0 breq .+38 ; 0x122c <__addsf3x+0x5c>
1206: 59 3f cpi r21, 0xF9 ; 249
1208: 50 f4 brcc .+20 ; 0x121e <__addsf3x+0x4e>
120a: 50 3e cpi r21, 0xE0 ; 224
120c: 68 f1 brcs .+90 ; 0x1268 <__addsf3x+0x98>
120e: 1a 16 cp r1, r26
1210: f0 40 sbci r31, 0x00 ; 0
1212: a2 2f mov r26, r18
1214: 23 2f mov r18, r19
1216: 34 2f mov r19, r20
1218: 44 27 eor r20, r20
121a: 58 5f subi r21, 0xF8 ; 248
121c: f3 cf rjmp .-26 ; 0x1204 <__addsf3x+0x34>
121e: 46 95 lsr r20
1220: 37 95 ror r19
1222: 27 95 ror r18
1224: a7 95 ror r26
1226: f0 40 sbci r31, 0x00 ; 0
1228: 53 95 inc r21
122a: c9 f7 brne .-14 ; 0x121e <__addsf3x+0x4e>
122c: 7e f4 brtc .+30 ; 0x124c <__addsf3x+0x7c>
122e: 1f 16 cp r1, r31
1230: ba 0b sbc r27, r26
1232: 62 0b sbc r22, r18
1234: 73 0b sbc r23, r19
1236: 84 0b sbc r24, r20
1238: ba f0 brmi .+46 ; 0x1268 <__addsf3x+0x98>
123a: 91 50 subi r25, 0x01 ; 1
123c: a1 f0 breq .+40 ; 0x1266 <__addsf3x+0x96>
123e: ff 0f add r31, r31
1240: bb 1f adc r27, r27
1242: 66 1f adc r22, r22
1244: 77 1f adc r23, r23
1246: 88 1f adc r24, r24
1248: c2 f7 brpl .-16 ; 0x123a <__addsf3x+0x6a>
124a: 0e c0 rjmp .+28 ; 0x1268 <__addsf3x+0x98>
124c: ba 0f add r27, r26
124e: 62 1f adc r22, r18
1250: 73 1f adc r23, r19
1252: 84 1f adc r24, r20
1254: 48 f4 brcc .+18 ; 0x1268 <__addsf3x+0x98>
1256: 87 95 ror r24
1258: 77 95 ror r23
125a: 67 95 ror r22
125c: b7 95 ror r27
125e: f7 95 ror r31
1260: 9e 3f cpi r25, 0xFE ; 254
1262: 08 f0 brcs .+2 ; 0x1266 <__addsf3x+0x96>
1264: b3 cf rjmp .-154 ; 0x11cc <__addsf3+0x1e>
1266: 93 95 inc r25
1268: 88 0f add r24, r24
126a: 08 f0 brcs .+2 ; 0x126e <__addsf3x+0x9e>
126c: 99 27 eor r25, r25
126e: ee 0f add r30, r30
1270: 97 95 ror r25
1272: 87 95 ror r24
1274: 08 95 ret
00001276 <__cmpsf2>:
1276: d4 d0 rcall .+424 ; 0x1420 <__fp_cmp>
1278: 08 f4 brcc .+2 ; 0x127c <__cmpsf2+0x6>
127a: 81 e0 ldi r24, 0x01 ; 1
127c: 08 95 ret
0000127e <__divsf3>:
127e: 0c d0 rcall .+24 ; 0x1298 <__divsf3x>
1280: 0a c1 rjmp .+532 ; 0x1496 <__fp_round>
1282: 02 d1 rcall .+516 ; 0x1488 <__fp_pscB>
1284: 40 f0 brcs .+16 ; 0x1296 <__divsf3+0x18>
1286: f9 d0 rcall .+498 ; 0x147a <__fp_pscA>
1288: 30 f0 brcs .+12 ; 0x1296 <__divsf3+0x18>
128a: 21 f4 brne .+8 ; 0x1294 <__divsf3+0x16>
128c: 5f 3f cpi r21, 0xFF ; 255
128e: 19 f0 breq .+6 ; 0x1296 <__divsf3+0x18>
1290: eb c0 rjmp .+470 ; 0x1468 <__fp_inf>
1292: 51 11 cpse r21, r1
1294: 34 c1 rjmp .+616 ; 0x14fe <__fp_szero>
1296: ee c0 rjmp .+476 ; 0x1474 <__fp_nan>
00001298 <__divsf3x>:
1298: 0f d1 rcall .+542 ; 0x14b8 <__fp_split3>
129a: 98 f3 brcs .-26 ; 0x1282 <__divsf3+0x4>
0000129c <__divsf3_pse>:
129c: 99 23 and r25, r25
129e: c9 f3 breq .-14 ; 0x1292 <__divsf3+0x14>
12a0: 55 23 and r21, r21
12a2: b1 f3 breq .-20 ; 0x1290 <__divsf3+0x12>
12a4: 95 1b sub r25, r21
12a6: 55 0b sbc r21, r21
12a8: bb 27 eor r27, r27
12aa: aa 27 eor r26, r26
12ac: 62 17 cp r22, r18
12ae: 73 07 cpc r23, r19
12b0: 84 07 cpc r24, r20
12b2: 38 f0 brcs .+14 ; 0x12c2 <__divsf3_pse+0x26>
12b4: 9f 5f subi r25, 0xFF ; 255
12b6: 5f 4f sbci r21, 0xFF ; 255
12b8: 22 0f add r18, r18
12ba: 33 1f adc r19, r19
12bc: 44 1f adc r20, r20
12be: aa 1f adc r26, r26
12c0: a9 f3 breq .-22 ; 0x12ac <__divsf3_pse+0x10>
12c2: 33 d0 rcall .+102 ; 0x132a <__divsf3_pse+0x8e>
12c4: 0e 2e mov r0, r30
12c6: 3a f0 brmi .+14 ; 0x12d6 <__divsf3_pse+0x3a>
12c8: e0 e8 ldi r30, 0x80 ; 128
12ca: 30 d0 rcall .+96 ; 0x132c <__divsf3_pse+0x90>
12cc: 91 50 subi r25, 0x01 ; 1
12ce: 50 40 sbci r21, 0x00 ; 0
12d0: e6 95 lsr r30
12d2: 00 1c adc r0, r0
12d4: ca f7 brpl .-14 ; 0x12c8 <__divsf3_pse+0x2c>
12d6: 29 d0 rcall .+82 ; 0x132a <__divsf3_pse+0x8e>
12d8: fe 2f mov r31, r30
12da: 27 d0 rcall .+78 ; 0x132a <__divsf3_pse+0x8e>
12dc: 66 0f add r22, r22
12de: 77 1f adc r23, r23
12e0: 88 1f adc r24, r24
12e2: bb 1f adc r27, r27
12e4: 26 17 cp r18, r22
12e6: 37 07 cpc r19, r23
12e8: 48 07 cpc r20, r24
12ea: ab 07 cpc r26, r27
12ec: b0 e8 ldi r27, 0x80 ; 128
12ee: 09 f0 breq .+2 ; 0x12f2 <__divsf3_pse+0x56>
12f0: bb 0b sbc r27, r27
12f2: 80 2d mov r24, r0
12f4: bf 01 movw r22, r30
12f6: ff 27 eor r31, r31
12f8: 93 58 subi r25, 0x83 ; 131
12fa: 5f 4f sbci r21, 0xFF ; 255
12fc: 2a f0 brmi .+10 ; 0x1308 <__divsf3_pse+0x6c>
12fe: 9e 3f cpi r25, 0xFE ; 254
1300: 51 05 cpc r21, r1
1302: 68 f0 brcs .+26 ; 0x131e <__divsf3_pse+0x82>
1304: b1 c0 rjmp .+354 ; 0x1468 <__fp_inf>
1306: fb c0 rjmp .+502 ; 0x14fe <__fp_szero>
1308: 5f 3f cpi r21, 0xFF ; 255
130a: ec f3 brlt .-6 ; 0x1306 <__divsf3_pse+0x6a>
130c: 98 3e cpi r25, 0xE8 ; 232
130e: dc f3 brlt .-10 ; 0x1306 <__divsf3_pse+0x6a>
1310: 86 95 lsr r24
1312: 77 95 ror r23
1314: 67 95 ror r22
1316: b7 95 ror r27
1318: f7 95 ror r31
131a: 9f 5f subi r25, 0xFF ; 255
131c: c9 f7 brne .-14 ; 0x1310 <__divsf3_pse+0x74>
131e: 88 0f add r24, r24
1320: 91 1d adc r25, r1
1322: 96 95 lsr r25
1324: 87 95 ror r24
1326: 97 f9 bld r25, 7
1328: 08 95 ret
132a: e1 e0 ldi r30, 0x01 ; 1
132c: 66 0f add r22, r22
132e: 77 1f adc r23, r23
1330: 88 1f adc r24, r24
1332: bb 1f adc r27, r27
1334: 62 17 cp r22, r18
1336: 73 07 cpc r23, r19
1338: 84 07 cpc r24, r20
133a: ba 07 cpc r27, r26
133c: 20 f0 brcs .+8 ; 0x1346 <__divsf3_pse+0xaa>
133e: 62 1b sub r22, r18
1340: 73 0b sbc r23, r19
1342: 84 0b sbc r24, r20
1344: ba 0b sbc r27, r26
1346: ee 1f adc r30, r30
1348: 88 f7 brcc .-30 ; 0x132c <__divsf3_pse+0x90>
134a: e0 95 com r30
134c: 08 95 ret
0000134e <__fixunssfsi>:
134e: bc d0 rcall .+376 ; 0x14c8 <__fp_splitA>
1350: 88 f0 brcs .+34 ; 0x1374 <__fixunssfsi+0x26>
1352: 9f 57 subi r25, 0x7F ; 127
1354: 90 f0 brcs .+36 ; 0x137a <__fixunssfsi+0x2c>
1356: b9 2f mov r27, r25
1358: 99 27 eor r25, r25
135a: b7 51 subi r27, 0x17 ; 23
135c: a0 f0 brcs .+40 ; 0x1386 <__fixunssfsi+0x38>
135e: d1 f0 breq .+52 ; 0x1394 <__fixunssfsi+0x46>
1360: 66 0f add r22, r22
1362: 77 1f adc r23, r23
1364: 88 1f adc r24, r24
1366: 99 1f adc r25, r25
1368: 1a f0 brmi .+6 ; 0x1370 <__fixunssfsi+0x22>
136a: ba 95 dec r27
136c: c9 f7 brne .-14 ; 0x1360 <__fixunssfsi+0x12>
136e: 12 c0 rjmp .+36 ; 0x1394 <__fixunssfsi+0x46>
1370: b1 30 cpi r27, 0x01 ; 1
1372: 81 f0 breq .+32 ; 0x1394 <__fixunssfsi+0x46>
1374: c3 d0 rcall .+390 ; 0x14fc <__fp_zero>
1376: b1 e0 ldi r27, 0x01 ; 1
1378: 08 95 ret
137a: c0 c0 rjmp .+384 ; 0x14fc <__fp_zero>
137c: 67 2f mov r22, r23
137e: 78 2f mov r23, r24
1380: 88 27 eor r24, r24
1382: b8 5f subi r27, 0xF8 ; 248
1384: 39 f0 breq .+14 ; 0x1394 <__fixunssfsi+0x46>
1386: b9 3f cpi r27, 0xF9 ; 249
1388: cc f3 brlt .-14 ; 0x137c <__fixunssfsi+0x2e>
138a: 86 95 lsr r24
138c: 77 95 ror r23
138e: 67 95 ror r22
1390: b3 95 inc r27
1392: d9 f7 brne .-10 ; 0x138a <__fixunssfsi+0x3c>
1394: 3e f4 brtc .+14 ; 0x13a4 <__fixunssfsi+0x56>
1396: 90 95 com r25
1398: 80 95 com r24
139a: 70 95 com r23
139c: 61 95 neg r22
139e: 7f 4f sbci r23, 0xFF ; 255
13a0: 8f 4f sbci r24, 0xFF ; 255
13a2: 9f 4f sbci r25, 0xFF ; 255
13a4: 08 95 ret
000013a6 <__floatunsisf>:
13a6: e8 94 clt
13a8: 09 c0 rjmp .+18 ; 0x13bc <__floatsisf+0x12>
000013aa <__floatsisf>:
13aa: 97 fb bst r25, 7
13ac: 3e f4 brtc .+14 ; 0x13bc <__floatsisf+0x12>
13ae: 90 95 com r25
13b0: 80 95 com r24
13b2: 70 95 com r23
13b4: 61 95 neg r22
13b6: 7f 4f sbci r23, 0xFF ; 255
13b8: 8f 4f sbci r24, 0xFF ; 255
13ba: 9f 4f sbci r25, 0xFF ; 255
13bc: 99 23 and r25, r25
13be: a9 f0 breq .+42 ; 0x13ea <__floatsisf+0x40>
13c0: f9 2f mov r31, r25
13c2: 96 e9 ldi r25, 0x96 ; 150
13c4: bb 27 eor r27, r27
13c6: 93 95 inc r25
13c8: f6 95 lsr r31
13ca: 87 95 ror r24
13cc: 77 95 ror r23
13ce: 67 95 ror r22
13d0: b7 95 ror r27
13d2: f1 11 cpse r31, r1
13d4: f8 cf rjmp .-16 ; 0x13c6 <__floatsisf+0x1c>
13d6: fa f4 brpl .+62 ; 0x1416 <__floatsisf+0x6c>
13d8: bb 0f add r27, r27
13da: 11 f4 brne .+4 ; 0x13e0 <__floatsisf+0x36>
13dc: 60 ff sbrs r22, 0
13de: 1b c0 rjmp .+54 ; 0x1416 <__floatsisf+0x6c>
13e0: 6f 5f subi r22, 0xFF ; 255
13e2: 7f 4f sbci r23, 0xFF ; 255
13e4: 8f 4f sbci r24, 0xFF ; 255
13e6: 9f 4f sbci r25, 0xFF ; 255
13e8: 16 c0 rjmp .+44 ; 0x1416 <__floatsisf+0x6c>
13ea: 88 23 and r24, r24
13ec: 11 f0 breq .+4 ; 0x13f2 <__floatsisf+0x48>
13ee: 96 e9 ldi r25, 0x96 ; 150
13f0: 11 c0 rjmp .+34 ; 0x1414 <__floatsisf+0x6a>
13f2: 77 23 and r23, r23
13f4: 21 f0 breq .+8 ; 0x13fe <__floatsisf+0x54>
13f6: 9e e8 ldi r25, 0x8E ; 142
13f8: 87 2f mov r24, r23
13fa: 76 2f mov r23, r22
13fc: 05 c0 rjmp .+10 ; 0x1408 <__floatsisf+0x5e>
13fe: 66 23 and r22, r22
1400: 71 f0 breq .+28 ; 0x141e <__floatsisf+0x74>
1402: 96 e8 ldi r25, 0x86 ; 134
1404: 86 2f mov r24, r22
1406: 70 e0 ldi r23, 0x00 ; 0
1408: 60 e0 ldi r22, 0x00 ; 0
140a: 2a f0 brmi .+10 ; 0x1416 <__floatsisf+0x6c>
140c: 9a 95 dec r25
140e: 66 0f add r22, r22
1410: 77 1f adc r23, r23
1412: 88 1f adc r24, r24
1414: da f7 brpl .-10 ; 0x140c <__floatsisf+0x62>
1416: 88 0f add r24, r24
1418: 96 95 lsr r25
141a: 87 95 ror r24
141c: 97 f9 bld r25, 7
141e: 08 95 ret
00001420 <__fp_cmp>:
1420: 99 0f add r25, r25
1422: 00 08 sbc r0, r0
1424: 55 0f add r21, r21
1426: aa 0b sbc r26, r26
1428: e0 e8 ldi r30, 0x80 ; 128
142a: fe ef ldi r31, 0xFE ; 254
142c: 16 16 cp r1, r22
142e: 17 06 cpc r1, r23
1430: e8 07 cpc r30, r24
1432: f9 07 cpc r31, r25
1434: c0 f0 brcs .+48 ; 0x1466 <__fp_cmp+0x46>
1436: 12 16 cp r1, r18
1438: 13 06 cpc r1, r19
143a: e4 07 cpc r30, r20
143c: f5 07 cpc r31, r21
143e: 98 f0 brcs .+38 ; 0x1466 <__fp_cmp+0x46>
1440: 62 1b sub r22, r18
1442: 73 0b sbc r23, r19
1444: 84 0b sbc r24, r20
1446: 95 0b sbc r25, r21
1448: 39 f4 brne .+14 ; 0x1458 <__fp_cmp+0x38>
144a: 0a 26 eor r0, r26
144c: 61 f0 breq .+24 ; 0x1466 <__fp_cmp+0x46>
144e: 23 2b or r18, r19
1450: 24 2b or r18, r20
1452: 25 2b or r18, r21
1454: 21 f4 brne .+8 ; 0x145e <__fp_cmp+0x3e>
1456: 08 95 ret
1458: 0a 26 eor r0, r26
145a: 09 f4 brne .+2 ; 0x145e <__fp_cmp+0x3e>
145c: a1 40 sbci r26, 0x01 ; 1
145e: a6 95 lsr r26
1460: 8f ef ldi r24, 0xFF ; 255
1462: 81 1d adc r24, r1
1464: 81 1d adc r24, r1
1466: 08 95 ret
00001468 <__fp_inf>:
1468: 97 f9 bld r25, 7
146a: 9f 67 ori r25, 0x7F ; 127
146c: 80 e8 ldi r24, 0x80 ; 128
146e: 70 e0 ldi r23, 0x00 ; 0
1470: 60 e0 ldi r22, 0x00 ; 0
1472: 08 95 ret
00001474 <__fp_nan>:
1474: 9f ef ldi r25, 0xFF ; 255
1476: 80 ec ldi r24, 0xC0 ; 192
1478: 08 95 ret
0000147a <__fp_pscA>:
147a: 00 24 eor r0, r0
147c: 0a 94 dec r0
147e: 16 16 cp r1, r22
1480: 17 06 cpc r1, r23
1482: 18 06 cpc r1, r24
1484: 09 06 cpc r0, r25
1486: 08 95 ret
00001488 <__fp_pscB>:
1488: 00 24 eor r0, r0
148a: 0a 94 dec r0
148c: 12 16 cp r1, r18
148e: 13 06 cpc r1, r19
1490: 14 06 cpc r1, r20
1492: 05 06 cpc r0, r21
1494: 08 95 ret
00001496 <__fp_round>:
1496: 09 2e mov r0, r25
1498: 03 94 inc r0
149a: 00 0c add r0, r0
149c: 11 f4 brne .+4 ; 0x14a2 <__fp_round+0xc>
149e: 88 23 and r24, r24
14a0: 52 f0 brmi .+20 ; 0x14b6 <__fp_round+0x20>
14a2: bb 0f add r27, r27
14a4: 40 f4 brcc .+16 ; 0x14b6 <__fp_round+0x20>
14a6: bf 2b or r27, r31
14a8: 11 f4 brne .+4 ; 0x14ae <__fp_round+0x18>
14aa: 60 ff sbrs r22, 0
14ac: 04 c0 rjmp .+8 ; 0x14b6 <__fp_round+0x20>
14ae: 6f 5f subi r22, 0xFF ; 255
14b0: 7f 4f sbci r23, 0xFF ; 255
14b2: 8f 4f sbci r24, 0xFF ; 255
14b4: 9f 4f sbci r25, 0xFF ; 255
14b6: 08 95 ret
000014b8 <__fp_split3>:
14b8: 57 fd sbrc r21, 7
14ba: 90 58 subi r25, 0x80 ; 128
14bc: 44 0f add r20, r20
14be: 55 1f adc r21, r21
14c0: 59 f0 breq .+22 ; 0x14d8 <__fp_splitA+0x10>
14c2: 5f 3f cpi r21, 0xFF ; 255
14c4: 71 f0 breq .+28 ; 0x14e2 <__fp_splitA+0x1a>
14c6: 47 95 ror r20
000014c8 <__fp_splitA>:
14c8: 88 0f add r24, r24
14ca: 97 fb bst r25, 7
14cc: 99 1f adc r25, r25
14ce: 61 f0 breq .+24 ; 0x14e8 <__fp_splitA+0x20>
14d0: 9f 3f cpi r25, 0xFF ; 255
14d2: 79 f0 breq .+30 ; 0x14f2 <__fp_splitA+0x2a>
14d4: 87 95 ror r24
14d6: 08 95 ret
14d8: 12 16 cp r1, r18
14da: 13 06 cpc r1, r19
14dc: 14 06 cpc r1, r20
14de: 55 1f adc r21, r21
14e0: f2 cf rjmp .-28 ; 0x14c6 <__fp_split3+0xe>
14e2: 46 95 lsr r20
14e4: f1 df rcall .-30 ; 0x14c8 <__fp_splitA>
14e6: 08 c0 rjmp .+16 ; 0x14f8 <__fp_splitA+0x30>
14e8: 16 16 cp r1, r22
14ea: 17 06 cpc r1, r23
14ec: 18 06 cpc r1, r24
14ee: 99 1f adc r25, r25
14f0: f1 cf rjmp .-30 ; 0x14d4 <__fp_splitA+0xc>
14f2: 86 95 lsr r24
14f4: 71 05 cpc r23, r1
14f6: 61 05 cpc r22, r1
14f8: 08 94 sec
14fa: 08 95 ret
000014fc <__fp_zero>:
14fc: e8 94 clt
000014fe <__fp_szero>:
14fe: bb 27 eor r27, r27
1500: 66 27 eor r22, r22
1502: 77 27 eor r23, r23
1504: cb 01 movw r24, r22
1506: 97 f9 bld r25, 7
1508: 08 95 ret
0000150a <__gesf2>:
150a: 8a df rcall .-236 ; 0x1420 <__fp_cmp>
150c: 08 f4 brcc .+2 ; 0x1510 <__gesf2+0x6>
150e: 8f ef ldi r24, 0xFF ; 255
1510: 08 95 ret
00001512 <__mulsf3>:
1512: 0b d0 rcall .+22 ; 0x152a <__mulsf3x>
1514: c0 cf rjmp .-128 ; 0x1496 <__fp_round>
1516: b1 df rcall .-158 ; 0x147a <__fp_pscA>
1518: 28 f0 brcs .+10 ; 0x1524 <__mulsf3+0x12>
151a: b6 df rcall .-148 ; 0x1488 <__fp_pscB>
151c: 18 f0 brcs .+6 ; 0x1524 <__mulsf3+0x12>
151e: 95 23 and r25, r21
1520: 09 f0 breq .+2 ; 0x1524 <__mulsf3+0x12>
1522: a2 cf rjmp .-188 ; 0x1468 <__fp_inf>
1524: a7 cf rjmp .-178 ; 0x1474 <__fp_nan>
1526: 11 24 eor r1, r1
1528: ea cf rjmp .-44 ; 0x14fe <__fp_szero>
0000152a <__mulsf3x>:
152a: c6 df rcall .-116 ; 0x14b8 <__fp_split3>
152c: a0 f3 brcs .-24 ; 0x1516 <__mulsf3+0x4>
0000152e <__mulsf3_pse>:
152e: 95 9f mul r25, r21
1530: d1 f3 breq .-12 ; 0x1526 <__mulsf3+0x14>
1532: 95 0f add r25, r21
1534: 50 e0 ldi r21, 0x00 ; 0
1536: 55 1f adc r21, r21
1538: 62 9f mul r22, r18
153a: f0 01 movw r30, r0
153c: 72 9f mul r23, r18
153e: bb 27 eor r27, r27
1540: f0 0d add r31, r0
1542: b1 1d adc r27, r1
1544: 63 9f mul r22, r19
1546: aa 27 eor r26, r26
1548: f0 0d add r31, r0
154a: b1 1d adc r27, r1
154c: aa 1f adc r26, r26
154e: 64 9f mul r22, r20
1550: 66 27 eor r22, r22
1552: b0 0d add r27, r0
1554: a1 1d adc r26, r1
1556: 66 1f adc r22, r22
1558: 82 9f mul r24, r18
155a: 22 27 eor r18, r18
155c: b0 0d add r27, r0
155e: a1 1d adc r26, r1
1560: 62 1f adc r22, r18
1562: 73 9f mul r23, r19
1564: b0 0d add r27, r0
1566: a1 1d adc r26, r1
1568: 62 1f adc r22, r18
156a: 83 9f mul r24, r19
156c: a0 0d add r26, r0
156e: 61 1d adc r22, r1
1570: 22 1f adc r18, r18
1572: 74 9f mul r23, r20
1574: 33 27 eor r19, r19
1576: a0 0d add r26, r0
1578: 61 1d adc r22, r1
157a: 23 1f adc r18, r19
157c: 84 9f mul r24, r20
157e: 60 0d add r22, r0
1580: 21 1d adc r18, r1
1582: 82 2f mov r24, r18
1584: 76 2f mov r23, r22
1586: 6a 2f mov r22, r26
1588: 11 24 eor r1, r1
158a: 9f 57 subi r25, 0x7F ; 127
158c: 50 40 sbci r21, 0x00 ; 0
158e: 8a f0 brmi .+34 ; 0x15b2 <__mulsf3_pse+0x84>
1590: e1 f0 breq .+56 ; 0x15ca <__mulsf3_pse+0x9c>
1592: 88 23 and r24, r24
1594: 4a f0 brmi .+18 ; 0x15a8 <__mulsf3_pse+0x7a>
1596: ee 0f add r30, r30
1598: ff 1f adc r31, r31
159a: bb 1f adc r27, r27
159c: 66 1f adc r22, r22
159e: 77 1f adc r23, r23
15a0: 88 1f adc r24, r24
15a2: 91 50 subi r25, 0x01 ; 1
15a4: 50 40 sbci r21, 0x00 ; 0
15a6: a9 f7 brne .-22 ; 0x1592 <__mulsf3_pse+0x64>
15a8: 9e 3f cpi r25, 0xFE ; 254
15aa: 51 05 cpc r21, r1
15ac: 70 f0 brcs .+28 ; 0x15ca <__mulsf3_pse+0x9c>
15ae: 5c cf rjmp .-328 ; 0x1468 <__fp_inf>
15b0: a6 cf rjmp .-180 ; 0x14fe <__fp_szero>
15b2: 5f 3f cpi r21, 0xFF ; 255
15b4: ec f3 brlt .-6 ; 0x15b0 <__mulsf3_pse+0x82>
15b6: 98 3e cpi r25, 0xE8 ; 232
15b8: dc f3 brlt .-10 ; 0x15b0 <__mulsf3_pse+0x82>
15ba: 86 95 lsr r24
15bc: 77 95 ror r23
15be: 67 95 ror r22
15c0: b7 95 ror r27
15c2: f7 95 ror r31
15c4: e7 95 ror r30
15c6: 9f 5f subi r25, 0xFF ; 255
15c8: c1 f7 brne .-16 ; 0x15ba <__mulsf3_pse+0x8c>
15ca: fe 2b or r31, r30
15cc: 88 0f add r24, r24
15ce: 91 1d adc r25, r1
15d0: 96 95 lsr r25
15d2: 87 95 ror r24
15d4: 97 f9 bld r25, 7
15d6: 08 95 ret
000015d8 <__divmodhi4>:
15d8: 97 fb bst r25, 7
15da: 07 2e mov r0, r23
15dc: 16 f4 brtc .+4 ; 0x15e2 <__divmodhi4+0xa>
15de: 00 94 com r0
15e0: 07 d0 rcall .+14 ; 0x15f0 <__divmodhi4_neg1>
15e2: 77 fd sbrc r23, 7
15e4: 09 d0 rcall .+18 ; 0x15f8 <__divmodhi4_neg2>
15e6: 0e 94 0c 0b call 0x1618 ; 0x1618 <__udivmodhi4>
15ea: 07 fc sbrc r0, 7
15ec: 05 d0 rcall .+10 ; 0x15f8 <__divmodhi4_neg2>
15ee: 3e f4 brtc .+14 ; 0x15fe <__divmodhi4_exit>
000015f0 <__divmodhi4_neg1>:
15f0: 90 95 com r25
15f2: 81 95 neg r24
15f4: 9f 4f sbci r25, 0xFF ; 255
15f6: 08 95 ret
000015f8 <__divmodhi4_neg2>:
15f8: 70 95 com r23
15fa: 61 95 neg r22
15fc: 7f 4f sbci r23, 0xFF ; 255
000015fe <__divmodhi4_exit>:
15fe: 08 95 ret
00001600 <__umulhisi3>:
1600: a2 9f mul r26, r18
1602: b0 01 movw r22, r0
1604: b3 9f mul r27, r19
1606: c0 01 movw r24, r0
1608: a3 9f mul r26, r19
160a: 01 d0 rcall .+2 ; 0x160e <__umulhisi3+0xe>
160c: b2 9f mul r27, r18
160e: 70 0d add r23, r0
1610: 81 1d adc r24, r1
1612: 11 24 eor r1, r1
1614: 91 1d adc r25, r1
1616: 08 95 ret
00001618 <__udivmodhi4>:
1618: aa 1b sub r26, r26
161a: bb 1b sub r27, r27
161c: 51 e1 ldi r21, 0x11 ; 17
161e: 07 c0 rjmp .+14 ; 0x162e <__udivmodhi4_ep>
00001620 <__udivmodhi4_loop>:
1620: aa 1f adc r26, r26
1622: bb 1f adc r27, r27
1624: a6 17 cp r26, r22
1626: b7 07 cpc r27, r23
1628: 10 f0 brcs .+4 ; 0x162e <__udivmodhi4_ep>
162a: a6 1b sub r26, r22
162c: b7 0b sbc r27, r23
0000162e <__udivmodhi4_ep>:
162e: 88 1f adc r24, r24
1630: 99 1f adc r25, r25
1632: 5a 95 dec r21
1634: a9 f7 brne .-22 ; 0x1620 <__udivmodhi4_loop>
1636: 80 95 com r24
1638: 90 95 com r25
163a: bc 01 movw r22, r24
163c: cd 01 movw r24, r26
163e: 08 95 ret
00001640 <__tablejump2__>:
1640: ee 0f add r30, r30
1642: ff 1f adc r31, r31
00001644 <__tablejump__>:
1644: 05 90 lpm r0, Z+
1646: f4 91 lpm r31, Z
1648: e0 2d mov r30, r0
164a: 09 94 ijmp
0000164c <dtostrf>:
164c: ef 92 push r14
164e: 0f 93 push r16
1650: 1f 93 push r17
1652: cf 93 push r28
1654: c0 2f mov r28, r16
1656: 47 ff sbrs r20, 7
1658: 02 c0 rjmp .+4 ; 0x165e <dtostrf+0x12>
165a: 34 e1 ldi r19, 0x14 ; 20
165c: 01 c0 rjmp .+2 ; 0x1660 <dtostrf+0x14>
165e: 34 e0 ldi r19, 0x04 ; 4
1660: e4 2f mov r30, r20
1662: ff 27 eor r31, r31
1664: e7 fd sbrc r30, 7
1666: f0 95 com r31
1668: f7 ff sbrs r31, 7
166a: 03 c0 rjmp .+6 ; 0x1672 <dtostrf+0x26>
166c: f1 95 neg r31
166e: e1 95 neg r30
1670: f1 09 sbc r31, r1
1672: e3 2e mov r14, r19
1674: 02 2f mov r16, r18
1676: 2e 2f mov r18, r30
1678: 4c 2f mov r20, r28
167a: 51 2f mov r21, r17
167c: 0e 94 5d 0b call 0x16ba ; 0x16ba <dtoa_prf>
1680: 8c 2f mov r24, r28
1682: 91 2f mov r25, r17
1684: cf 91 pop r28
1686: 1f 91 pop r17
1688: 0f 91 pop r16
168a: ef 90 pop r14
168c: 08 95 ret
0000168e <utoa>:
168e: fb 01 movw r30, r22
1690: 9f 01 movw r18, r30
1692: 42 30 cpi r20, 0x02 ; 2
1694: 74 f0 brlt .+28 ; 0x16b2 <utoa+0x24>
1696: 45 32 cpi r20, 0x25 ; 37
1698: 64 f4 brge .+24 ; 0x16b2 <utoa+0x24>
169a: 64 2f mov r22, r20
169c: 77 27 eor r23, r23
169e: 0e 94 0c 0b call 0x1618 ; 0x1618 <__udivmodhi4>
16a2: 80 5d subi r24, 0xD0 ; 208
16a4: 8a 33 cpi r24, 0x3A ; 58
16a6: 0c f0 brlt .+2 ; 0x16aa <utoa+0x1c>
16a8: 89 5d subi r24, 0xD9 ; 217
16aa: 81 93 st Z+, r24
16ac: cb 01 movw r24, r22
16ae: 00 97 sbiw r24, 0x00 ; 0
16b0: a1 f7 brne .-24 ; 0x169a <utoa+0xc>
16b2: 10 82 st Z, r1
16b4: c9 01 movw r24, r18
16b6: 0c 94 b2 0d jmp 0x1b64 ; 0x1b64 <strrev>
000016ba <dtoa_prf>:
16ba: 6f 92 push r6
16bc: 7f 92 push r7
16be: 9f 92 push r9
16c0: af 92 push r10
16c2: bf 92 push r11
16c4: cf 92 push r12
16c6: df 92 push r13
16c8: ef 92 push r14
16ca: ff 92 push r15
16cc: 0f 93 push r16
16ce: 1f 93 push r17
16d0: cf 93 push r28
16d2: df 93 push r29
16d4: cd b7 in r28, 0x3d ; 61
16d6: de b7 in r29, 0x3e ; 62
16d8: 29 97 sbiw r28, 0x09 ; 9
16da: 0f b6 in r0, 0x3f ; 63
16dc: f8 94 cli
16de: de bf out 0x3e, r29 ; 62
16e0: 0f be out 0x3f, r0 ; 63
16e2: cd bf out 0x3d, r28 ; 61
16e4: 6a 01 movw r12, r20
16e6: b2 2e mov r11, r18
16e8: 10 2f mov r17, r16
16ea: 0c 33 cpi r16, 0x3C ; 60
16ec: 18 f4 brcc .+6 ; 0x16f4 <dtoa_prf+0x3a>
16ee: f0 2e mov r15, r16
16f0: f3 94 inc r15
16f2: 02 c0 rjmp .+4 ; 0x16f8 <dtoa_prf+0x3e>
16f4: 5c e3 ldi r21, 0x3C ; 60
16f6: f5 2e mov r15, r21
16f8: 0f 2d mov r16, r15
16fa: 27 e0 ldi r18, 0x07 ; 7
16fc: ae 01 movw r20, r28
16fe: 4f 5f subi r20, 0xFF ; 255
1700: 5f 4f sbci r21, 0xFF ; 255
1702: 0e 94 da 0c call 0x19b4 ; 0x19b4 <__ftoa_engine>
1706: 79 81 ldd r23, Y+1 ; 0x01
1708: 27 2f mov r18, r23
170a: 29 70 andi r18, 0x09 ; 9
170c: 21 30 cpi r18, 0x01 ; 1
170e: 31 f0 breq .+12 ; 0x171c <dtoa_prf+0x62>
1710: e1 fc sbrc r14, 1
1712: 06 c0 rjmp .+12 ; 0x1720 <dtoa_prf+0x66>
1714: e0 fe sbrs r14, 0
1716: 06 c0 rjmp .+12 ; 0x1724 <dtoa_prf+0x6a>
1718: 60 e2 ldi r22, 0x20 ; 32
171a: 05 c0 rjmp .+10 ; 0x1726 <dtoa_prf+0x6c>
171c: 6d e2 ldi r22, 0x2D ; 45
171e: 03 c0 rjmp .+6 ; 0x1726 <dtoa_prf+0x6c>
1720: 6b e2 ldi r22, 0x2B ; 43
1722: 01 c0 rjmp .+2 ; 0x1726 <dtoa_prf+0x6c>
1724: 60 e0 ldi r22, 0x00 ; 0
1726: 73 ff sbrs r23, 3
1728: 3d c0 rjmp .+122 ; 0x17a4 <dtoa_prf+0xea>
172a: 66 23 and r22, r22
172c: 11 f0 breq .+4 ; 0x1732 <dtoa_prf+0x78>
172e: 84 e0 ldi r24, 0x04 ; 4
1730: 01 c0 rjmp .+2 ; 0x1734 <dtoa_prf+0x7a>
1732: 83 e0 ldi r24, 0x03 ; 3
1734: 8b 15 cp r24, r11
1736: 10 f4 brcc .+4 ; 0x173c <dtoa_prf+0x82>
1738: b8 1a sub r11, r24
173a: 01 c0 rjmp .+2 ; 0x173e <dtoa_prf+0x84>
173c: b1 2c mov r11, r1
173e: e4 fc sbrc r14, 4
1740: 0b c0 rjmp .+22 ; 0x1758 <dtoa_prf+0x9e>
1742: 8b 2d mov r24, r11
1744: f6 01 movw r30, r12
1746: 90 e2 ldi r25, 0x20 ; 32
1748: 02 c0 rjmp .+4 ; 0x174e <dtoa_prf+0x94>
174a: 91 93 st Z+, r25
174c: 81 50 subi r24, 0x01 ; 1
174e: 81 11 cpse r24, r1
1750: fc cf rjmp .-8 ; 0x174a <dtoa_prf+0x90>
1752: cb 0c add r12, r11
1754: d1 1c adc r13, r1
1756: b1 2c mov r11, r1
1758: 66 23 and r22, r22
175a: 19 f0 breq .+6 ; 0x1762 <dtoa_prf+0xa8>
175c: d6 01 movw r26, r12
175e: 6d 93 st X+, r22
1760: 6d 01 movw r12, r26
1762: e2 fe sbrs r14, 2
1764: 0a c0 rjmp .+20 ; 0x177a <dtoa_prf+0xc0>
1766: 8e e4 ldi r24, 0x4E ; 78
1768: f6 01 movw r30, r12
176a: 80 83 st Z, r24
176c: 91 e4 ldi r25, 0x41 ; 65
176e: 91 83 std Z+1, r25 ; 0x01
1770: 82 83 std Z+2, r24 ; 0x02
1772: f3 e0 ldi r31, 0x03 ; 3
1774: cf 0e add r12, r31
1776: d1 1c adc r13, r1
1778: 0c c0 rjmp .+24 ; 0x1792 <dtoa_prf+0xd8>
177a: 8e e6 ldi r24, 0x6E ; 110
177c: d6 01 movw r26, r12
177e: 8c 93 st X, r24
1780: 91 e6 ldi r25, 0x61 ; 97
1782: 11 96 adiw r26, 0x01 ; 1
1784: 9c 93 st X, r25
1786: 11 97 sbiw r26, 0x01 ; 1
1788: 12 96 adiw r26, 0x02 ; 2
178a: 8c 93 st X, r24
178c: b3 e0 ldi r27, 0x03 ; 3
178e: cb 0e add r12, r27
1790: d1 1c adc r13, r1
1792: 8b 2d mov r24, r11
1794: f6 01 movw r30, r12
1796: 90 e2 ldi r25, 0x20 ; 32
1798: 02 c0 rjmp .+4 ; 0x179e <dtoa_prf+0xe4>
179a: 91 93 st Z+, r25
179c: 81 50 subi r24, 0x01 ; 1
179e: 81 11 cpse r24, r1
17a0: fc cf rjmp .-8 ; 0x179a <dtoa_prf+0xe0>
17a2: 40 c0 rjmp .+128 ; 0x1824 <dtoa_prf+0x16a>
17a4: 72 ff sbrs r23, 2
17a6: 45 c0 rjmp .+138 ; 0x1832 <dtoa_prf+0x178>
17a8: 66 23 and r22, r22
17aa: 11 f0 breq .+4 ; 0x17b0 <dtoa_prf+0xf6>
17ac: 84 e0 ldi r24, 0x04 ; 4
17ae: 01 c0 rjmp .+2 ; 0x17b2 <dtoa_prf+0xf8>
17b0: 83 e0 ldi r24, 0x03 ; 3
17b2: 8b 15 cp r24, r11
17b4: 10 f4 brcc .+4 ; 0x17ba <dtoa_prf+0x100>
17b6: b8 1a sub r11, r24
17b8: 01 c0 rjmp .+2 ; 0x17bc <dtoa_prf+0x102>
17ba: b1 2c mov r11, r1
17bc: e4 fc sbrc r14, 4
17be: 0b c0 rjmp .+22 ; 0x17d6 <dtoa_prf+0x11c>
17c0: 8b 2d mov r24, r11
17c2: f6 01 movw r30, r12
17c4: 90 e2 ldi r25, 0x20 ; 32
17c6: 02 c0 rjmp .+4 ; 0x17cc <dtoa_prf+0x112>
17c8: 91 93 st Z+, r25
17ca: 81 50 subi r24, 0x01 ; 1
17cc: 81 11 cpse r24, r1
17ce: fc cf rjmp .-8 ; 0x17c8 <dtoa_prf+0x10e>
17d0: cb 0c add r12, r11
17d2: d1 1c adc r13, r1
17d4: b1 2c mov r11, r1
17d6: 66 23 and r22, r22
17d8: 19 f0 breq .+6 ; 0x17e0 <dtoa_prf+0x126>
17da: f6 01 movw r30, r12
17dc: 61 93 st Z+, r22
17de: 6f 01 movw r12, r30
17e0: e2 fe sbrs r14, 2
17e2: 0e c0 rjmp .+28 ; 0x1800 <dtoa_prf+0x146>
17e4: 89 e4 ldi r24, 0x49 ; 73
17e6: d6 01 movw r26, r12
17e8: 8c 93 st X, r24
17ea: 8e e4 ldi r24, 0x4E ; 78
17ec: 11 96 adiw r26, 0x01 ; 1
17ee: 8c 93 st X, r24
17f0: 11 97 sbiw r26, 0x01 ; 1
17f2: 86 e4 ldi r24, 0x46 ; 70
17f4: 12 96 adiw r26, 0x02 ; 2
17f6: 8c 93 st X, r24
17f8: b3 e0 ldi r27, 0x03 ; 3
17fa: cb 0e add r12, r27
17fc: d1 1c adc r13, r1
17fe: 0a c0 rjmp .+20 ; 0x1814 <dtoa_prf+0x15a>
1800: 89 e6 ldi r24, 0x69 ; 105
1802: f6 01 movw r30, r12
1804: 80 83 st Z, r24
1806: 8e e6 ldi r24, 0x6E ; 110
1808: 81 83 std Z+1, r24 ; 0x01
180a: 86 e6 ldi r24, 0x66 ; 102
180c: 82 83 std Z+2, r24 ; 0x02
180e: f3 e0 ldi r31, 0x03 ; 3
1810: cf 0e add r12, r31
1812: d1 1c adc r13, r1
1814: 8b 2d mov r24, r11
1816: f6 01 movw r30, r12
1818: 90 e2 ldi r25, 0x20 ; 32
181a: 02 c0 rjmp .+4 ; 0x1820 <dtoa_prf+0x166>
181c: 91 93 st Z+, r25
181e: 81 50 subi r24, 0x01 ; 1
1820: 81 11 cpse r24, r1
1822: fc cf rjmp .-8 ; 0x181c <dtoa_prf+0x162>
1824: f6 01 movw r30, r12
1826: eb 0d add r30, r11
1828: f1 1d adc r31, r1
182a: 10 82 st Z, r1
182c: 2e ef ldi r18, 0xFE ; 254
182e: 3f ef ldi r19, 0xFF ; 255
1830: ac c0 rjmp .+344 ; 0x198a <dtoa_prf+0x2d0>
1832: a1 e0 ldi r26, 0x01 ; 1
1834: 61 11 cpse r22, r1
1836: 01 c0 rjmp .+2 ; 0x183a <dtoa_prf+0x180>
1838: a0 e0 ldi r26, 0x00 ; 0
183a: 4a 2f mov r20, r26
183c: 50 e0 ldi r21, 0x00 ; 0
183e: 18 16 cp r1, r24
1840: 19 06 cpc r1, r25
1842: 24 f4 brge .+8 ; 0x184c <dtoa_prf+0x192>
1844: 9c 01 movw r18, r24
1846: 2f 5f subi r18, 0xFF ; 255
1848: 3f 4f sbci r19, 0xFF ; 255
184a: 02 c0 rjmp .+4 ; 0x1850 <dtoa_prf+0x196>
184c: 21 e0 ldi r18, 0x01 ; 1
184e: 30 e0 ldi r19, 0x00 ; 0
1850: 24 0f add r18, r20
1852: 35 1f adc r19, r21
1854: 11 23 and r17, r17
1856: 29 f0 breq .+10 ; 0x1862 <dtoa_prf+0x1a8>
1858: 41 2f mov r20, r17
185a: 50 e0 ldi r21, 0x00 ; 0
185c: 4f 5f subi r20, 0xFF ; 255
185e: 5f 4f sbci r21, 0xFF ; 255
1860: 02 c0 rjmp .+4 ; 0x1866 <dtoa_prf+0x1ac>
1862: 40 e0 ldi r20, 0x00 ; 0
1864: 50 e0 ldi r21, 0x00 ; 0
1866: 42 0f add r20, r18
1868: 53 1f adc r21, r19
186a: 2b 2d mov r18, r11
186c: 30 e0 ldi r19, 0x00 ; 0
186e: 42 17 cp r20, r18
1870: 53 07 cpc r21, r19
1872: 14 f4 brge .+4 ; 0x1878 <dtoa_prf+0x1be>
1874: b4 1a sub r11, r20
1876: 01 c0 rjmp .+2 ; 0x187a <dtoa_prf+0x1c0>
1878: b1 2c mov r11, r1
187a: 3e 2d mov r19, r14
187c: 30 71 andi r19, 0x10 ; 16
187e: e4 fc sbrc r14, 4
1880: 0d c0 rjmp .+26 ; 0x189c <dtoa_prf+0x1e2>
1882: e3 fc sbrc r14, 3
1884: 0b c0 rjmp .+22 ; 0x189c <dtoa_prf+0x1e2>
1886: 2b 2d mov r18, r11
1888: f6 01 movw r30, r12
188a: 40 e2 ldi r20, 0x20 ; 32
188c: 02 c0 rjmp .+4 ; 0x1892 <dtoa_prf+0x1d8>
188e: 41 93 st Z+, r20
1890: 21 50 subi r18, 0x01 ; 1
1892: 21 11 cpse r18, r1
1894: fc cf rjmp .-8 ; 0x188e <dtoa_prf+0x1d4>
1896: cb 0c add r12, r11
1898: d1 1c adc r13, r1
189a: b1 2c mov r11, r1
189c: aa 23 and r26, r26
189e: 19 f0 breq .+6 ; 0x18a6 <dtoa_prf+0x1ec>
18a0: d6 01 movw r26, r12
18a2: 6d 93 st X+, r22
18a4: 6d 01 movw r12, r26
18a6: 31 11 cpse r19, r1
18a8: 0b c0 rjmp .+22 ; 0x18c0 <dtoa_prf+0x206>
18aa: 2b 2d mov r18, r11
18ac: f6 01 movw r30, r12
18ae: 30 e3 ldi r19, 0x30 ; 48
18b0: 02 c0 rjmp .+4 ; 0x18b6 <dtoa_prf+0x1fc>
18b2: 31 93 st Z+, r19
18b4: 21 50 subi r18, 0x01 ; 1
18b6: 21 11 cpse r18, r1
18b8: fc cf rjmp .-8 ; 0x18b2 <dtoa_prf+0x1f8>
18ba: cb 0c add r12, r11
18bc: d1 1c adc r13, r1
18be: b1 2c mov r11, r1
18c0: f8 0e add r15, r24
18c2: 0a 81 ldd r16, Y+2 ; 0x02
18c4: 40 e1 ldi r20, 0x10 ; 16
18c6: a4 2e mov r10, r20
18c8: a7 22 and r10, r23
18ca: 74 ff sbrs r23, 4
18cc: 03 c0 rjmp .+6 ; 0x18d4 <dtoa_prf+0x21a>
18ce: 01 33 cpi r16, 0x31 ; 49
18d0: 09 f4 brne .+2 ; 0x18d4 <dtoa_prf+0x21a>
18d2: fa 94 dec r15
18d4: 1f 14 cp r1, r15
18d6: 2c f4 brge .+10 ; 0x18e2 <dtoa_prf+0x228>
18d8: 2f 2d mov r18, r15
18da: 29 30 cpi r18, 0x09 ; 9
18dc: 18 f0 brcs .+6 ; 0x18e4 <dtoa_prf+0x22a>
18de: 28 e0 ldi r18, 0x08 ; 8
18e0: 01 c0 rjmp .+2 ; 0x18e4 <dtoa_prf+0x22a>
18e2: 21 e0 ldi r18, 0x01 ; 1
18e4: ac 01 movw r20, r24
18e6: 97 ff sbrs r25, 7
18e8: 02 c0 rjmp .+4 ; 0x18ee <dtoa_prf+0x234>
18ea: 40 e0 ldi r20, 0x00 ; 0
18ec: 50 e0 ldi r21, 0x00 ; 0
18ee: 60 e0 ldi r22, 0x00 ; 0
18f0: 70 e0 ldi r23, 0x00 ; 0
18f2: 3e e2 ldi r19, 0x2E ; 46
18f4: 93 2e mov r9, r19
18f6: fc 01 movw r30, r24
18f8: e2 1b sub r30, r18
18fa: f1 09 sbc r31, r1
18fc: 9f 01 movw r18, r30
18fe: dc 01 movw r26, r24
1900: a4 1b sub r26, r20
1902: b5 0b sbc r27, r21
1904: fe 01 movw r30, r28
1906: 31 96 adiw r30, 0x01 ; 1
1908: ea 0f add r30, r26
190a: fb 1f adc r31, r27
190c: a1 2f mov r26, r17
190e: b0 e0 ldi r27, 0x00 ; 0
1910: 66 24 eor r6, r6
1912: 77 24 eor r7, r7
1914: 6a 1a sub r6, r26
1916: 7b 0a sbc r7, r27
1918: 4f 3f cpi r20, 0xFF ; 255
191a: 1f ef ldi r17, 0xFF ; 255
191c: 51 07 cpc r21, r17
191e: 19 f4 brne .+6 ; 0x1926 <dtoa_prf+0x26c>
1920: d6 01 movw r26, r12
1922: 9d 92 st X+, r9
1924: 6d 01 movw r12, r26
1926: 84 17 cp r24, r20
1928: 95 07 cpc r25, r21
192a: 54 f0 brlt .+20 ; 0x1940 <dtoa_prf+0x286>
192c: 24 17 cp r18, r20
192e: 35 07 cpc r19, r21
1930: 3c f4 brge .+14 ; 0x1940 <dtoa_prf+0x286>
1932: 7f 01 movw r14, r30
1934: e6 0e add r14, r22
1936: f7 1e adc r15, r23
1938: d7 01 movw r26, r14
193a: 11 96 adiw r26, 0x01 ; 1
193c: 1c 91 ld r17, X
193e: 01 c0 rjmp .+2 ; 0x1942 <dtoa_prf+0x288>
1940: 10 e3 ldi r17, 0x30 ; 48
1942: 41 50 subi r20, 0x01 ; 1
1944: 51 09 sbc r21, r1
1946: 6f 5f subi r22, 0xFF ; 255
1948: 7f 4f sbci r23, 0xFF ; 255
194a: 46 15 cp r20, r6
194c: 57 05 cpc r21, r7
194e: 24 f0 brlt .+8 ; 0x1958 <dtoa_prf+0x29e>
1950: d6 01 movw r26, r12
1952: 1d 93 st X+, r17
1954: 6d 01 movw r12, r26
1956: e0 cf rjmp .-64 ; 0x1918 <dtoa_prf+0x25e>
1958: 48 17 cp r20, r24
195a: 59 07 cpc r21, r25
195c: 39 f4 brne .+14 ; 0x196c <dtoa_prf+0x2b2>
195e: 06 33 cpi r16, 0x36 ; 54
1960: 20 f4 brcc .+8 ; 0x196a <dtoa_prf+0x2b0>
1962: 05 33 cpi r16, 0x35 ; 53
1964: 19 f4 brne .+6 ; 0x196c <dtoa_prf+0x2b2>
1966: a1 10 cpse r10, r1
1968: 01 c0 rjmp .+2 ; 0x196c <dtoa_prf+0x2b2>
196a: 11 e3 ldi r17, 0x31 ; 49
196c: f6 01 movw r30, r12
196e: 11 93 st Z+, r17
1970: 8b 2d mov r24, r11
1972: df 01 movw r26, r30
1974: 90 e2 ldi r25, 0x20 ; 32
1976: 02 c0 rjmp .+4 ; 0x197c <dtoa_prf+0x2c2>
1978: 9d 93 st X+, r25
197a: 81 50 subi r24, 0x01 ; 1
197c: 81 11 cpse r24, r1
197e: fc cf rjmp .-8 ; 0x1978 <dtoa_prf+0x2be>
1980: eb 0d add r30, r11
1982: f1 1d adc r31, r1
1984: 10 82 st Z, r1
1986: 20 e0 ldi r18, 0x00 ; 0
1988: 30 e0 ldi r19, 0x00 ; 0
198a: c9 01 movw r24, r18
198c: 29 96 adiw r28, 0x09 ; 9
198e: 0f b6 in r0, 0x3f ; 63
1990: f8 94 cli
1992: de bf out 0x3e, r29 ; 62
1994: 0f be out 0x3f, r0 ; 63
1996: cd bf out 0x3d, r28 ; 61
1998: df 91 pop r29
199a: cf 91 pop r28
199c: 1f 91 pop r17
199e: 0f 91 pop r16
19a0: ff 90 pop r15
19a2: ef 90 pop r14
19a4: df 90 pop r13
19a6: cf 90 pop r12
19a8: bf 90 pop r11
19aa: af 90 pop r10
19ac: 9f 90 pop r9
19ae: 7f 90 pop r7
19b0: 6f 90 pop r6
19b2: 08 95 ret
000019b4 <__ftoa_engine>:
19b4: 28 30 cpi r18, 0x08 ; 8
19b6: 08 f0 brcs .+2 ; 0x19ba <__ftoa_engine+0x6>
19b8: 27 e0 ldi r18, 0x07 ; 7
19ba: 33 27 eor r19, r19
19bc: da 01 movw r26, r20
19be: 99 0f add r25, r25
19c0: 31 1d adc r19, r1
19c2: 87 fd sbrc r24, 7
19c4: 91 60 ori r25, 0x01 ; 1
19c6: 00 96 adiw r24, 0x00 ; 0
19c8: 61 05 cpc r22, r1
19ca: 71 05 cpc r23, r1
19cc: 39 f4 brne .+14 ; 0x19dc <__ftoa_engine+0x28>
19ce: 32 60 ori r19, 0x02 ; 2
19d0: 2e 5f subi r18, 0xFE ; 254
19d2: 3d 93 st X+, r19
19d4: 30 e3 ldi r19, 0x30 ; 48
19d6: 2a 95 dec r18
19d8: e1 f7 brne .-8 ; 0x19d2 <__ftoa_engine+0x1e>
19da: 08 95 ret
19dc: 9f 3f cpi r25, 0xFF ; 255
19de: 30 f0 brcs .+12 ; 0x19ec <__ftoa_engine+0x38>
19e0: 80 38 cpi r24, 0x80 ; 128
19e2: 71 05 cpc r23, r1
19e4: 61 05 cpc r22, r1
19e6: 09 f0 breq .+2 ; 0x19ea <__ftoa_engine+0x36>
19e8: 3c 5f subi r19, 0xFC ; 252
19ea: 3c 5f subi r19, 0xFC ; 252
19ec: 3d 93 st X+, r19
19ee: 91 30 cpi r25, 0x01 ; 1
19f0: 08 f0 brcs .+2 ; 0x19f4 <__ftoa_engine+0x40>
19f2: 80 68 ori r24, 0x80 ; 128
19f4: 91 1d adc r25, r1
19f6: df 93 push r29
19f8: cf 93 push r28
19fa: 1f 93 push r17
19fc: 0f 93 push r16
19fe: ff 92 push r15
1a00: ef 92 push r14
1a02: 19 2f mov r17, r25
1a04: 98 7f andi r25, 0xF8 ; 248
1a06: 96 95 lsr r25
1a08: e9 2f mov r30, r25
1a0a: 96 95 lsr r25
1a0c: 96 95 lsr r25
1a0e: e9 0f add r30, r25
1a10: ff 27 eor r31, r31
1a12: e2 55 subi r30, 0x52 ; 82
1a14: ff 4f sbci r31, 0xFF ; 255
1a16: 99 27 eor r25, r25
1a18: 33 27 eor r19, r19
1a1a: ee 24 eor r14, r14
1a1c: ff 24 eor r15, r15
1a1e: a7 01 movw r20, r14
1a20: e7 01 movw r28, r14
1a22: 05 90 lpm r0, Z+
1a24: 08 94 sec
1a26: 07 94 ror r0
1a28: 28 f4 brcc .+10 ; 0x1a34 <__ftoa_engine+0x80>
1a2a: 36 0f add r19, r22
1a2c: e7 1e adc r14, r23
1a2e: f8 1e adc r15, r24
1a30: 49 1f adc r20, r25
1a32: 51 1d adc r21, r1
1a34: 66 0f add r22, r22
1a36: 77 1f adc r23, r23
1a38: 88 1f adc r24, r24
1a3a: 99 1f adc r25, r25
1a3c: 06 94 lsr r0
1a3e: a1 f7 brne .-24 ; 0x1a28 <__ftoa_engine+0x74>
1a40: 05 90 lpm r0, Z+
1a42: 07 94 ror r0
1a44: 28 f4 brcc .+10 ; 0x1a50 <__ftoa_engine+0x9c>
1a46: e7 0e add r14, r23
1a48: f8 1e adc r15, r24
1a4a: 49 1f adc r20, r25
1a4c: 56 1f adc r21, r22
1a4e: c1 1d adc r28, r1
1a50: 77 0f add r23, r23
1a52: 88 1f adc r24, r24
1a54: 99 1f adc r25, r25
1a56: 66 1f adc r22, r22
1a58: 06 94 lsr r0
1a5a: a1 f7 brne .-24 ; 0x1a44 <__ftoa_engine+0x90>
1a5c: 05 90 lpm r0, Z+
1a5e: 07 94 ror r0
1a60: 28 f4 brcc .+10 ; 0x1a6c <__ftoa_engine+0xb8>
1a62: f8 0e add r15, r24
1a64: 49 1f adc r20, r25
1a66: 56 1f adc r21, r22
1a68: c7 1f adc r28, r23
1a6a: d1 1d adc r29, r1
1a6c: 88 0f add r24, r24
1a6e: 99 1f adc r25, r25
1a70: 66 1f adc r22, r22
1a72: 77 1f adc r23, r23
1a74: 06 94 lsr r0
1a76: a1 f7 brne .-24 ; 0x1a60 <__ftoa_engine+0xac>
1a78: 05 90 lpm r0, Z+
1a7a: 07 94 ror r0
1a7c: 20 f4 brcc .+8 ; 0x1a86 <__ftoa_engine+0xd2>
1a7e: 49 0f add r20, r25
1a80: 56 1f adc r21, r22
1a82: c7 1f adc r28, r23
1a84: d8 1f adc r29, r24
1a86: 99 0f add r25, r25
1a88: 66 1f adc r22, r22
1a8a: 77 1f adc r23, r23
1a8c: 88 1f adc r24, r24
1a8e: 06 94 lsr r0
1a90: a9 f7 brne .-22 ; 0x1a7c <__ftoa_engine+0xc8>
1a92: 84 91 lpm r24, Z
1a94: 10 95 com r17
1a96: 17 70 andi r17, 0x07 ; 7
1a98: 41 f0 breq .+16 ; 0x1aaa <__ftoa_engine+0xf6>
1a9a: d6 95 lsr r29
1a9c: c7 95 ror r28
1a9e: 57 95 ror r21
1aa0: 47 95 ror r20
1aa2: f7 94 ror r15
1aa4: e7 94 ror r14
1aa6: 1a 95 dec r17
1aa8: c1 f7 brne .-16 ; 0x1a9a <__ftoa_engine+0xe6>
1aaa: e4 e5 ldi r30, 0x54 ; 84
1aac: f0 e0 ldi r31, 0x00 ; 0
1aae: 68 94 set
1ab0: 15 90 lpm r1, Z+
1ab2: 15 91 lpm r17, Z+
1ab4: 35 91 lpm r19, Z+
1ab6: 65 91 lpm r22, Z+
1ab8: 95 91 lpm r25, Z+
1aba: 05 90 lpm r0, Z+
1abc: 7f e2 ldi r23, 0x2F ; 47
1abe: 73 95 inc r23
1ac0: e1 18 sub r14, r1
1ac2: f1 0a sbc r15, r17
1ac4: 43 0b sbc r20, r19
1ac6: 56 0b sbc r21, r22
1ac8: c9 0b sbc r28, r25
1aca: d0 09 sbc r29, r0
1acc: c0 f7 brcc .-16 ; 0x1abe <__ftoa_engine+0x10a>
1ace: e1 0c add r14, r1
1ad0: f1 1e adc r15, r17
1ad2: 43 1f adc r20, r19
1ad4: 56 1f adc r21, r22
1ad6: c9 1f adc r28, r25
1ad8: d0 1d adc r29, r0
1ada: 7e f4 brtc .+30 ; 0x1afa <__ftoa_engine+0x146>
1adc: 70 33 cpi r23, 0x30 ; 48
1ade: 11 f4 brne .+4 ; 0x1ae4 <__ftoa_engine+0x130>
1ae0: 8a 95 dec r24
1ae2: e6 cf rjmp .-52 ; 0x1ab0 <__ftoa_engine+0xfc>
1ae4: e8 94 clt
1ae6: 01 50 subi r16, 0x01 ; 1
1ae8: 30 f0 brcs .+12 ; 0x1af6 <__ftoa_engine+0x142>
1aea: 08 0f add r16, r24
1aec: 0a f4 brpl .+2 ; 0x1af0 <__ftoa_engine+0x13c>
1aee: 00 27 eor r16, r16
1af0: 02 17 cp r16, r18
1af2: 08 f4 brcc .+2 ; 0x1af6 <__ftoa_engine+0x142>
1af4: 20 2f mov r18, r16
1af6: 23 95 inc r18
1af8: 02 2f mov r16, r18
1afa: 7a 33 cpi r23, 0x3A ; 58
1afc: 28 f0 brcs .+10 ; 0x1b08 <__ftoa_engine+0x154>
1afe: 79 e3 ldi r23, 0x39 ; 57
1b00: 7d 93 st X+, r23
1b02: 2a 95 dec r18
1b04: e9 f7 brne .-6 ; 0x1b00 <__ftoa_engine+0x14c>
1b06: 10 c0 rjmp .+32 ; 0x1b28 <__ftoa_engine+0x174>
1b08: 7d 93 st X+, r23
1b0a: 2a 95 dec r18
1b0c: 89 f6 brne .-94 ; 0x1ab0 <__ftoa_engine+0xfc>
1b0e: 06 94 lsr r0
1b10: 97 95 ror r25
1b12: 67 95 ror r22
1b14: 37 95 ror r19
1b16: 17 95 ror r17
1b18: 17 94 ror r1
1b1a: e1 18 sub r14, r1
1b1c: f1 0a sbc r15, r17
1b1e: 43 0b sbc r20, r19
1b20: 56 0b sbc r21, r22
1b22: c9 0b sbc r28, r25
1b24: d0 09 sbc r29, r0
1b26: 98 f0 brcs .+38 ; 0x1b4e <__ftoa_engine+0x19a>
1b28: 23 95 inc r18
1b2a: 7e 91 ld r23, -X
1b2c: 73 95 inc r23
1b2e: 7a 33 cpi r23, 0x3A ; 58
1b30: 08 f0 brcs .+2 ; 0x1b34 <__ftoa_engine+0x180>
1b32: 70 e3 ldi r23, 0x30 ; 48
1b34: 7c 93 st X, r23
1b36: 20 13 cpse r18, r16
1b38: b8 f7 brcc .-18 ; 0x1b28 <__ftoa_engine+0x174>
1b3a: 7e 91 ld r23, -X
1b3c: 70 61 ori r23, 0x10 ; 16
1b3e: 7d 93 st X+, r23
1b40: 30 f0 brcs .+12 ; 0x1b4e <__ftoa_engine+0x19a>
1b42: 83 95 inc r24
1b44: 71 e3 ldi r23, 0x31 ; 49
1b46: 7d 93 st X+, r23
1b48: 70 e3 ldi r23, 0x30 ; 48
1b4a: 2a 95 dec r18
1b4c: e1 f7 brne .-8 ; 0x1b46 <__ftoa_engine+0x192>
1b4e: 11 24 eor r1, r1
1b50: ef 90 pop r14
1b52: ff 90 pop r15
1b54: 0f 91 pop r16
1b56: 1f 91 pop r17
1b58: cf 91 pop r28
1b5a: df 91 pop r29
1b5c: 99 27 eor r25, r25
1b5e: 87 fd sbrc r24, 7
1b60: 90 95 com r25
1b62: 08 95 ret
00001b64 <strrev>:
1b64: dc 01 movw r26, r24
1b66: fc 01 movw r30, r24
1b68: 67 2f mov r22, r23
1b6a: 71 91 ld r23, Z+
1b6c: 77 23 and r23, r23
1b6e: e1 f7 brne .-8 ; 0x1b68 <strrev+0x4>
1b70: 32 97 sbiw r30, 0x02 ; 2
1b72: 04 c0 rjmp .+8 ; 0x1b7c <strrev+0x18>
1b74: 7c 91 ld r23, X
1b76: 6d 93 st X+, r22
1b78: 70 83 st Z, r23
1b7a: 62 91 ld r22, -Z
1b7c: ae 17 cp r26, r30
1b7e: bf 07 cpc r27, r31
1b80: c8 f3 brcs .-14 ; 0x1b74 <strrev+0x10>
1b82: 08 95 ret
00001b84 <_exit>:
1b84: f8 94 cli
00001b86 <__stop_program>:
1b86: ff cf rjmp .-2 ; 0x1b86 <__stop_program>
Reference in New Issue View Git Blame Copy Permalink