You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2740 lines
92 KiB
2740 lines
92 KiB
|
|
shiftin_try6_wLED.ino.elf: file format elf32-avr
|
|
|
|
|
|
Disassembly of section .text:
|
|
|
|
00000000 <__vectors>:
|
|
0: 0c 94 a2 00 jmp 0x144 ; 0x144 <__ctors_end>
|
|
4: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
8: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
c: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
10: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
14: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
18: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
1c: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
20: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
24: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
28: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
2c: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
30: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
34: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
38: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
3c: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
40: 0c 94 75 04 jmp 0x8ea ; 0x8ea <__vector_16>
|
|
44: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
48: 0c 94 43 04 jmp 0x886 ; 0x886 <__vector_18>
|
|
4c: 0c 94 1d 04 jmp 0x83a ; 0x83a <__vector_19>
|
|
50: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
54: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
58: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
5c: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
60: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
64: 0c 94 ca 00 jmp 0x194 ; 0x194 <__bad_interrupt>
|
|
|
|
00000068 <__trampolines_end>:
|
|
68: 00 00 nop
|
|
6a: 00 00 nop
|
|
6c: 24 00 .word 0x0024 ; ????
|
|
6e: 27 00 .word 0x0027 ; ????
|
|
70: 2a 00 .word 0x002a ; ????
|
|
|
|
00000072 <port_to_output_PGM>:
|
|
72: 00 00 00 00 25 00 28 00 2b 00 ....%.(.+.
|
|
|
|
0000007c <port_to_input_PGM>:
|
|
7c: 00 00 00 00 23 00 26 00 29 00 ....#.&.).
|
|
|
|
00000086 <digital_pin_to_port_PGM>:
|
|
86: 04 04 04 04 04 04 04 04 02 02 02 02 02 02 03 03 ................
|
|
96: 03 03 03 03 ....
|
|
|
|
0000009a <digital_pin_to_bit_mask_PGM>:
|
|
9a: 01 02 04 08 10 20 40 80 01 02 04 08 10 20 01 02 ..... @...... ..
|
|
aa: 04 08 10 20 ...
|
|
|
|
000000ae <digital_pin_to_timer_PGM>:
|
|
ae: 00 00 00 08 00 02 01 00 00 03 04 07 00 00 00 00 ................
|
|
be: 00 00 00 00 ....
|
|
|
|
000000c2 <charTable>:
|
|
c2: 7e 30 6d 79 33 5b 5f 70 7f 7b 77 1f 0d 3d 4f 47 ~0my3[_p.{w..=OG
|
|
...
|
|
ee: 80 01 80 00 7e 30 6d 79 33 5b 5f 70 7f 7b 00 00 ....~0my3[_p.{..
|
|
fe: 00 00 00 00 00 77 1f 0d 3d 4f 47 00 37 00 00 00 .....w..=OG.7...
|
|
10e: 0e 00 00 00 67 00 00 00 00 00 00 00 00 00 00 00 ....g...........
|
|
11e: 00 00 00 08 00 77 1f 0d 3d 4f 47 00 37 00 00 00 .....w..=OG.7...
|
|
12e: 0e 00 15 1d 67 00 00 00 00 00 00 00 00 00 00 00 ....g...........
|
|
13e: 00 00 00 00 ....
|
|
|
|
00000142 <__ctors_start>:
|
|
142: bf 04 cpc r11, r15
|
|
|
|
00000144 <__ctors_end>:
|
|
144: 11 24 eor r1, r1
|
|
146: 1f be out 0x3f, r1 ; 63
|
|
148: cf ef ldi r28, 0xFF ; 255
|
|
14a: d8 e0 ldi r29, 0x08 ; 8
|
|
14c: de bf out 0x3e, r29 ; 62
|
|
14e: cd bf out 0x3d, r28 ; 61
|
|
|
|
00000150 <__do_copy_data>:
|
|
150: 11 e0 ldi r17, 0x01 ; 1
|
|
152: a0 e0 ldi r26, 0x00 ; 0
|
|
154: b1 e0 ldi r27, 0x01 ; 1
|
|
156: e4 e5 ldi r30, 0x54 ; 84
|
|
158: ff e0 ldi r31, 0x0F ; 15
|
|
15a: 02 c0 rjmp .+4 ; 0x160 <__do_copy_data+0x10>
|
|
15c: 05 90 lpm r0, Z+
|
|
15e: 0d 92 st X+, r0
|
|
160: a6 31 cpi r26, 0x16 ; 22
|
|
162: b1 07 cpc r27, r17
|
|
164: d9 f7 brne .-10 ; 0x15c <__do_copy_data+0xc>
|
|
|
|
00000166 <__do_clear_bss>:
|
|
166: 22 e0 ldi r18, 0x02 ; 2
|
|
168: a6 e1 ldi r26, 0x16 ; 22
|
|
16a: b1 e0 ldi r27, 0x01 ; 1
|
|
16c: 01 c0 rjmp .+2 ; 0x170 <.do_clear_bss_start>
|
|
|
|
0000016e <.do_clear_bss_loop>:
|
|
16e: 1d 92 st X+, r1
|
|
|
|
00000170 <.do_clear_bss_start>:
|
|
170: ac 33 cpi r26, 0x3C ; 60
|
|
172: b2 07 cpc r27, r18
|
|
174: e1 f7 brne .-8 ; 0x16e <.do_clear_bss_loop>
|
|
|
|
00000176 <__do_global_ctors>:
|
|
176: 10 e0 ldi r17, 0x00 ; 0
|
|
178: c2 ea ldi r28, 0xA2 ; 162
|
|
17a: d0 e0 ldi r29, 0x00 ; 0
|
|
17c: 04 c0 rjmp .+8 ; 0x186 <__do_global_ctors+0x10>
|
|
17e: 21 97 sbiw r28, 0x01 ; 1
|
|
180: fe 01 movw r30, r28
|
|
182: 0e 94 9d 07 call 0xf3a ; 0xf3a <__tablejump2__>
|
|
186: c1 3a cpi r28, 0xA1 ; 161
|
|
188: d1 07 cpc r29, r17
|
|
18a: c9 f7 brne .-14 ; 0x17e <__do_global_ctors+0x8>
|
|
18c: 0e 94 7a 05 call 0xaf4 ; 0xaf4 <main>
|
|
190: 0c 94 a8 07 jmp 0xf50 ; 0xf50 <_exit>
|
|
|
|
00000194 <__bad_interrupt>:
|
|
194: 0c 94 00 00 jmp 0 ; 0x0 <__vectors>
|
|
|
|
00000198 <Print::write(unsigned char const*, unsigned int)>:
|
|
|
|
// Public Methods //////////////////////////////////////////////////////////////
|
|
|
|
/* default implementation: may be overridden */
|
|
size_t Print::write(const uint8_t *buffer, size_t size)
|
|
{
|
|
198: cf 92 push r12
|
|
19a: df 92 push r13
|
|
19c: ef 92 push r14
|
|
19e: ff 92 push r15
|
|
1a0: 0f 93 push r16
|
|
1a2: 1f 93 push r17
|
|
1a4: cf 93 push r28
|
|
1a6: df 93 push r29
|
|
1a8: 6c 01 movw r12, r24
|
|
1aa: 7a 01 movw r14, r20
|
|
1ac: 8b 01 movw r16, r22
|
|
size_t n = 0;
|
|
1ae: c0 e0 ldi r28, 0x00 ; 0
|
|
1b0: d0 e0 ldi r29, 0x00 ; 0
|
|
while (size--) {
|
|
1b2: ce 15 cp r28, r14
|
|
1b4: df 05 cpc r29, r15
|
|
1b6: 89 f0 breq .+34 ; 0x1da <Print::write(unsigned char const*, unsigned int)+0x42>
|
|
if (write(*buffer++)) n++;
|
|
1b8: d8 01 movw r26, r16
|
|
1ba: 6d 91 ld r22, X+
|
|
1bc: 8d 01 movw r16, r26
|
|
1be: d6 01 movw r26, r12
|
|
1c0: ed 91 ld r30, X+
|
|
1c2: fc 91 ld r31, X
|
|
1c4: 01 90 ld r0, Z+
|
|
1c6: f0 81 ld r31, Z
|
|
1c8: e0 2d mov r30, r0
|
|
1ca: c6 01 movw r24, r12
|
|
1cc: 09 95 icall
|
|
1ce: 89 2b or r24, r25
|
|
1d0: 11 f4 brne .+4 ; 0x1d6 <Print::write(unsigned char const*, unsigned int)+0x3e>
|
|
1d2: 7e 01 movw r14, r28
|
|
1d4: 02 c0 rjmp .+4 ; 0x1da <Print::write(unsigned char const*, unsigned int)+0x42>
|
|
1d6: 21 96 adiw r28, 0x01 ; 1
|
|
1d8: ec cf rjmp .-40 ; 0x1b2 <Print::write(unsigned char const*, unsigned int)+0x1a>
|
|
else break;
|
|
}
|
|
return n;
|
|
}
|
|
1da: c7 01 movw r24, r14
|
|
1dc: df 91 pop r29
|
|
1de: cf 91 pop r28
|
|
1e0: 1f 91 pop r17
|
|
1e2: 0f 91 pop r16
|
|
1e4: ff 90 pop r15
|
|
1e6: ef 90 pop r14
|
|
1e8: df 90 pop r13
|
|
1ea: cf 90 pop r12
|
|
1ec: 08 95 ret
|
|
|
|
000001ee <Print::flush()>:
|
|
size_t println(unsigned long, int = DEC);
|
|
size_t println(double, int = 2);
|
|
size_t println(const Printable&);
|
|
size_t println(void);
|
|
|
|
virtual void flush() { /* Empty implementation for backward compatibility */ }
|
|
1ee: 08 95 ret
|
|
|
|
000001f0 <Print::availableForWrite()>:
|
|
return write((const uint8_t *)buffer, size);
|
|
}
|
|
|
|
// default to zero, meaning "a single write may block"
|
|
// should be overriden by subclasses with buffering
|
|
virtual int availableForWrite() { return 0; }
|
|
1f0: 80 e0 ldi r24, 0x00 ; 0
|
|
1f2: 90 e0 ldi r25, 0x00 ; 0
|
|
1f4: 08 95 ret
|
|
|
|
000001f6 <HardwareSerial::availableForWrite()>:
|
|
{
|
|
#if (SERIAL_TX_BUFFER_SIZE>256)
|
|
uint8_t oldSREG = SREG;
|
|
cli();
|
|
#endif
|
|
tx_buffer_index_t head = _tx_buffer_head;
|
|
1f6: fc 01 movw r30, r24
|
|
1f8: 53 8d ldd r21, Z+27 ; 0x1b
|
|
tx_buffer_index_t tail = _tx_buffer_tail;
|
|
1fa: 44 8d ldd r20, Z+28 ; 0x1c
|
|
1fc: 25 2f mov r18, r21
|
|
1fe: 30 e0 ldi r19, 0x00 ; 0
|
|
200: 84 2f mov r24, r20
|
|
202: 90 e0 ldi r25, 0x00 ; 0
|
|
#if (SERIAL_TX_BUFFER_SIZE>256)
|
|
SREG = oldSREG;
|
|
#endif
|
|
if (head >= tail) return SERIAL_TX_BUFFER_SIZE - 1 - head + tail;
|
|
204: 82 1b sub r24, r18
|
|
206: 93 0b sbc r25, r19
|
|
208: 54 17 cp r21, r20
|
|
20a: 10 f0 brcs .+4 ; 0x210 <HardwareSerial::availableForWrite()+0x1a>
|
|
20c: cf 96 adiw r24, 0x3f ; 63
|
|
20e: 08 95 ret
|
|
return tail - head - 1;
|
|
210: 01 97 sbiw r24, 0x01 ; 1
|
|
}
|
|
212: 08 95 ret
|
|
|
|
00000214 <HardwareSerial::read()>:
|
|
return _rx_buffer[_rx_buffer_tail];
|
|
}
|
|
}
|
|
|
|
int HardwareSerial::read(void)
|
|
{
|
|
214: fc 01 movw r30, r24
|
|
// if the head isn't ahead of the tail, we don't have any characters
|
|
if (_rx_buffer_head == _rx_buffer_tail) {
|
|
216: 91 8d ldd r25, Z+25 ; 0x19
|
|
218: 82 8d ldd r24, Z+26 ; 0x1a
|
|
21a: 98 17 cp r25, r24
|
|
21c: 61 f0 breq .+24 ; 0x236 <HardwareSerial::read()+0x22>
|
|
return -1;
|
|
} else {
|
|
unsigned char c = _rx_buffer[_rx_buffer_tail];
|
|
21e: 82 8d ldd r24, Z+26 ; 0x1a
|
|
220: df 01 movw r26, r30
|
|
222: a8 0f add r26, r24
|
|
224: b1 1d adc r27, r1
|
|
226: 5d 96 adiw r26, 0x1d ; 29
|
|
228: 8c 91 ld r24, X
|
|
_rx_buffer_tail = (rx_buffer_index_t)(_rx_buffer_tail + 1) % SERIAL_RX_BUFFER_SIZE;
|
|
22a: 92 8d ldd r25, Z+26 ; 0x1a
|
|
22c: 9f 5f subi r25, 0xFF ; 255
|
|
22e: 9f 73 andi r25, 0x3F ; 63
|
|
230: 92 8f std Z+26, r25 ; 0x1a
|
|
return c;
|
|
232: 90 e0 ldi r25, 0x00 ; 0
|
|
234: 08 95 ret
|
|
|
|
int HardwareSerial::read(void)
|
|
{
|
|
// if the head isn't ahead of the tail, we don't have any characters
|
|
if (_rx_buffer_head == _rx_buffer_tail) {
|
|
return -1;
|
|
236: 8f ef ldi r24, 0xFF ; 255
|
|
238: 9f ef ldi r25, 0xFF ; 255
|
|
} else {
|
|
unsigned char c = _rx_buffer[_rx_buffer_tail];
|
|
_rx_buffer_tail = (rx_buffer_index_t)(_rx_buffer_tail + 1) % SERIAL_RX_BUFFER_SIZE;
|
|
return c;
|
|
}
|
|
}
|
|
23a: 08 95 ret
|
|
|
|
0000023c <HardwareSerial::peek()>:
|
|
{
|
|
return ((unsigned int)(SERIAL_RX_BUFFER_SIZE + _rx_buffer_head - _rx_buffer_tail)) % SERIAL_RX_BUFFER_SIZE;
|
|
}
|
|
|
|
int HardwareSerial::peek(void)
|
|
{
|
|
23c: fc 01 movw r30, r24
|
|
if (_rx_buffer_head == _rx_buffer_tail) {
|
|
23e: 91 8d ldd r25, Z+25 ; 0x19
|
|
240: 82 8d ldd r24, Z+26 ; 0x1a
|
|
242: 98 17 cp r25, r24
|
|
244: 31 f0 breq .+12 ; 0x252 <HardwareSerial::peek()+0x16>
|
|
return -1;
|
|
} else {
|
|
return _rx_buffer[_rx_buffer_tail];
|
|
246: 82 8d ldd r24, Z+26 ; 0x1a
|
|
248: e8 0f add r30, r24
|
|
24a: f1 1d adc r31, r1
|
|
24c: 85 8d ldd r24, Z+29 ; 0x1d
|
|
24e: 90 e0 ldi r25, 0x00 ; 0
|
|
250: 08 95 ret
|
|
}
|
|
|
|
int HardwareSerial::peek(void)
|
|
{
|
|
if (_rx_buffer_head == _rx_buffer_tail) {
|
|
return -1;
|
|
252: 8f ef ldi r24, 0xFF ; 255
|
|
254: 9f ef ldi r25, 0xFF ; 255
|
|
} else {
|
|
return _rx_buffer[_rx_buffer_tail];
|
|
}
|
|
}
|
|
256: 08 95 ret
|
|
|
|
00000258 <HardwareSerial::available()>:
|
|
// clear any received data
|
|
_rx_buffer_head = _rx_buffer_tail;
|
|
}
|
|
|
|
int HardwareSerial::available(void)
|
|
{
|
|
258: fc 01 movw r30, r24
|
|
return ((unsigned int)(SERIAL_RX_BUFFER_SIZE + _rx_buffer_head - _rx_buffer_tail)) % SERIAL_RX_BUFFER_SIZE;
|
|
25a: 91 8d ldd r25, Z+25 ; 0x19
|
|
25c: 22 8d ldd r18, Z+26 ; 0x1a
|
|
25e: 89 2f mov r24, r25
|
|
260: 90 e0 ldi r25, 0x00 ; 0
|
|
262: 80 5c subi r24, 0xC0 ; 192
|
|
264: 9f 4f sbci r25, 0xFF ; 255
|
|
266: 82 1b sub r24, r18
|
|
268: 91 09 sbc r25, r1
|
|
}
|
|
26a: 8f 73 andi r24, 0x3F ; 63
|
|
26c: 99 27 eor r25, r25
|
|
26e: 08 95 ret
|
|
|
|
00000270 <Serial0_available()>:
|
|
#endif
|
|
|
|
// Function that can be weakly referenced by serialEventRun to prevent
|
|
// pulling in this file if it's not otherwise used.
|
|
bool Serial0_available() {
|
|
return Serial.available();
|
|
270: 87 e4 ldi r24, 0x47 ; 71
|
|
272: 91 e0 ldi r25, 0x01 ; 1
|
|
274: 0e 94 2c 01 call 0x258 ; 0x258 <HardwareSerial::available()>
|
|
278: 21 e0 ldi r18, 0x01 ; 1
|
|
27a: 89 2b or r24, r25
|
|
27c: 09 f4 brne .+2 ; 0x280 <Serial0_available()+0x10>
|
|
27e: 20 e0 ldi r18, 0x00 ; 0
|
|
}
|
|
280: 82 2f mov r24, r18
|
|
282: 08 95 ret
|
|
|
|
00000284 <HardwareSerial::_tx_udr_empty_irq()>:
|
|
}
|
|
|
|
// Actual interrupt handlers //////////////////////////////////////////////////////////////
|
|
|
|
void HardwareSerial::_tx_udr_empty_irq(void)
|
|
{
|
|
284: fc 01 movw r30, r24
|
|
// If interrupts are enabled, there must be more data in the output
|
|
// buffer. Send the next byte
|
|
unsigned char c = _tx_buffer[_tx_buffer_tail];
|
|
286: 84 8d ldd r24, Z+28 ; 0x1c
|
|
288: df 01 movw r26, r30
|
|
28a: a8 0f add r26, r24
|
|
28c: b1 1d adc r27, r1
|
|
28e: a3 5a subi r26, 0xA3 ; 163
|
|
290: bf 4f sbci r27, 0xFF ; 255
|
|
292: 2c 91 ld r18, X
|
|
_tx_buffer_tail = (_tx_buffer_tail + 1) % SERIAL_TX_BUFFER_SIZE;
|
|
294: 84 8d ldd r24, Z+28 ; 0x1c
|
|
296: 90 e0 ldi r25, 0x00 ; 0
|
|
298: 01 96 adiw r24, 0x01 ; 1
|
|
29a: 8f 73 andi r24, 0x3F ; 63
|
|
29c: 99 27 eor r25, r25
|
|
29e: 84 8f std Z+28, r24 ; 0x1c
|
|
|
|
*_udr = c;
|
|
2a0: a6 89 ldd r26, Z+22 ; 0x16
|
|
2a2: b7 89 ldd r27, Z+23 ; 0x17
|
|
2a4: 2c 93 st X, r18
|
|
|
|
// clear the TXC bit -- "can be cleared by writing a one to its bit
|
|
// location". This makes sure flush() won't return until the bytes
|
|
// actually got written
|
|
sbi(*_ucsra, TXC0);
|
|
2a6: a0 89 ldd r26, Z+16 ; 0x10
|
|
2a8: b1 89 ldd r27, Z+17 ; 0x11
|
|
2aa: 8c 91 ld r24, X
|
|
2ac: 80 64 ori r24, 0x40 ; 64
|
|
2ae: 8c 93 st X, r24
|
|
|
|
if (_tx_buffer_head == _tx_buffer_tail) {
|
|
2b0: 93 8d ldd r25, Z+27 ; 0x1b
|
|
2b2: 84 8d ldd r24, Z+28 ; 0x1c
|
|
2b4: 98 13 cpse r25, r24
|
|
2b6: 06 c0 rjmp .+12 ; 0x2c4 <HardwareSerial::_tx_udr_empty_irq()+0x40>
|
|
// Buffer empty, so disable interrupts
|
|
cbi(*_ucsrb, UDRIE0);
|
|
2b8: 02 88 ldd r0, Z+18 ; 0x12
|
|
2ba: f3 89 ldd r31, Z+19 ; 0x13
|
|
2bc: e0 2d mov r30, r0
|
|
2be: 80 81 ld r24, Z
|
|
2c0: 8f 7d andi r24, 0xDF ; 223
|
|
2c2: 80 83 st Z, r24
|
|
2c4: 08 95 ret
|
|
|
|
000002c6 <HardwareSerial::write(unsigned char)>:
|
|
// If we get here, nothing is queued anymore (DRIE is disabled) and
|
|
// the hardware finished tranmission (TXC is set).
|
|
}
|
|
|
|
size_t HardwareSerial::write(uint8_t c)
|
|
{
|
|
2c6: ef 92 push r14
|
|
2c8: ff 92 push r15
|
|
2ca: 0f 93 push r16
|
|
2cc: 1f 93 push r17
|
|
2ce: cf 93 push r28
|
|
2d0: df 93 push r29
|
|
2d2: ec 01 movw r28, r24
|
|
_written = true;
|
|
2d4: 81 e0 ldi r24, 0x01 ; 1
|
|
2d6: 88 8f std Y+24, r24 ; 0x18
|
|
// If the buffer and the data register is empty, just write the byte
|
|
// to the data register and be done. This shortcut helps
|
|
// significantly improve the effective datarate at high (>
|
|
// 500kbit/s) bitrates, where interrupt overhead becomes a slowdown.
|
|
if (_tx_buffer_head == _tx_buffer_tail && bit_is_set(*_ucsra, UDRE0)) {
|
|
2d8: 9b 8d ldd r25, Y+27 ; 0x1b
|
|
2da: 8c 8d ldd r24, Y+28 ; 0x1c
|
|
2dc: 98 13 cpse r25, r24
|
|
2de: 05 c0 rjmp .+10 ; 0x2ea <HardwareSerial::write(unsigned char)+0x24>
|
|
2e0: e8 89 ldd r30, Y+16 ; 0x10
|
|
2e2: f9 89 ldd r31, Y+17 ; 0x11
|
|
2e4: 80 81 ld r24, Z
|
|
2e6: 85 fd sbrc r24, 5
|
|
2e8: 24 c0 rjmp .+72 ; 0x332 <HardwareSerial::write(unsigned char)+0x6c>
|
|
2ea: f6 2e mov r15, r22
|
|
*_udr = c;
|
|
sbi(*_ucsra, TXC0);
|
|
return 1;
|
|
}
|
|
tx_buffer_index_t i = (_tx_buffer_head + 1) % SERIAL_TX_BUFFER_SIZE;
|
|
2ec: 0b 8d ldd r16, Y+27 ; 0x1b
|
|
2ee: 10 e0 ldi r17, 0x00 ; 0
|
|
2f0: 0f 5f subi r16, 0xFF ; 255
|
|
2f2: 1f 4f sbci r17, 0xFF ; 255
|
|
2f4: 0f 73 andi r16, 0x3F ; 63
|
|
2f6: 11 27 eor r17, r17
|
|
2f8: e0 2e mov r14, r16
|
|
|
|
// If the output buffer is full, there's nothing for it other than to
|
|
// wait for the interrupt handler to empty it a bit
|
|
while (i == _tx_buffer_tail) {
|
|
2fa: 8c 8d ldd r24, Y+28 ; 0x1c
|
|
2fc: e8 12 cpse r14, r24
|
|
2fe: 0c c0 rjmp .+24 ; 0x318 <HardwareSerial::write(unsigned char)+0x52>
|
|
if (bit_is_clear(SREG, SREG_I)) {
|
|
300: 0f b6 in r0, 0x3f ; 63
|
|
302: 07 fc sbrc r0, 7
|
|
304: fa cf rjmp .-12 ; 0x2fa <HardwareSerial::write(unsigned char)+0x34>
|
|
// Interrupts are disabled, so we'll have to poll the data
|
|
// register empty flag ourselves. If it is set, pretend an
|
|
// interrupt has happened and call the handler to free up
|
|
// space for us.
|
|
if(bit_is_set(*_ucsra, UDRE0))
|
|
306: e8 89 ldd r30, Y+16 ; 0x10
|
|
308: f9 89 ldd r31, Y+17 ; 0x11
|
|
30a: 80 81 ld r24, Z
|
|
30c: 85 ff sbrs r24, 5
|
|
30e: f5 cf rjmp .-22 ; 0x2fa <HardwareSerial::write(unsigned char)+0x34>
|
|
_tx_udr_empty_irq();
|
|
310: ce 01 movw r24, r28
|
|
312: 0e 94 42 01 call 0x284 ; 0x284 <HardwareSerial::_tx_udr_empty_irq()>
|
|
316: f1 cf rjmp .-30 ; 0x2fa <HardwareSerial::write(unsigned char)+0x34>
|
|
} else {
|
|
// nop, the interrupt handler will free up space for us
|
|
}
|
|
}
|
|
|
|
_tx_buffer[_tx_buffer_head] = c;
|
|
318: 8b 8d ldd r24, Y+27 ; 0x1b
|
|
31a: fe 01 movw r30, r28
|
|
31c: e8 0f add r30, r24
|
|
31e: f1 1d adc r31, r1
|
|
320: e3 5a subi r30, 0xA3 ; 163
|
|
322: ff 4f sbci r31, 0xFF ; 255
|
|
324: f0 82 st Z, r15
|
|
_tx_buffer_head = i;
|
|
326: 0b 8f std Y+27, r16 ; 0x1b
|
|
|
|
sbi(*_ucsrb, UDRIE0);
|
|
328: ea 89 ldd r30, Y+18 ; 0x12
|
|
32a: fb 89 ldd r31, Y+19 ; 0x13
|
|
32c: 80 81 ld r24, Z
|
|
32e: 80 62 ori r24, 0x20 ; 32
|
|
330: 07 c0 rjmp .+14 ; 0x340 <HardwareSerial::write(unsigned char)+0x7a>
|
|
// If the buffer and the data register is empty, just write the byte
|
|
// to the data register and be done. This shortcut helps
|
|
// significantly improve the effective datarate at high (>
|
|
// 500kbit/s) bitrates, where interrupt overhead becomes a slowdown.
|
|
if (_tx_buffer_head == _tx_buffer_tail && bit_is_set(*_ucsra, UDRE0)) {
|
|
*_udr = c;
|
|
332: ee 89 ldd r30, Y+22 ; 0x16
|
|
334: ff 89 ldd r31, Y+23 ; 0x17
|
|
336: 60 83 st Z, r22
|
|
sbi(*_ucsra, TXC0);
|
|
338: e8 89 ldd r30, Y+16 ; 0x10
|
|
33a: f9 89 ldd r31, Y+17 ; 0x11
|
|
33c: 80 81 ld r24, Z
|
|
33e: 80 64 ori r24, 0x40 ; 64
|
|
340: 80 83 st Z, r24
|
|
_tx_buffer_head = i;
|
|
|
|
sbi(*_ucsrb, UDRIE0);
|
|
|
|
return 1;
|
|
}
|
|
342: 81 e0 ldi r24, 0x01 ; 1
|
|
344: 90 e0 ldi r25, 0x00 ; 0
|
|
346: df 91 pop r29
|
|
348: cf 91 pop r28
|
|
34a: 1f 91 pop r17
|
|
34c: 0f 91 pop r16
|
|
34e: ff 90 pop r15
|
|
350: ef 90 pop r14
|
|
352: 08 95 ret
|
|
|
|
00000354 <HardwareSerial::flush()>:
|
|
if (head >= tail) return SERIAL_TX_BUFFER_SIZE - 1 - head + tail;
|
|
return tail - head - 1;
|
|
}
|
|
|
|
void HardwareSerial::flush()
|
|
{
|
|
354: cf 93 push r28
|
|
356: df 93 push r29
|
|
358: ec 01 movw r28, r24
|
|
// If we have never written a byte, no need to flush. This special
|
|
// case is needed since there is no way to force the TXC (transmit
|
|
// complete) bit to 1 during initialization
|
|
if (!_written)
|
|
35a: 88 8d ldd r24, Y+24 ; 0x18
|
|
35c: 88 23 and r24, r24
|
|
35e: c9 f0 breq .+50 ; 0x392 <HardwareSerial::flush()+0x3e>
|
|
return;
|
|
|
|
while (bit_is_set(*_ucsrb, UDRIE0) || bit_is_clear(*_ucsra, TXC0)) {
|
|
360: ea 89 ldd r30, Y+18 ; 0x12
|
|
362: fb 89 ldd r31, Y+19 ; 0x13
|
|
364: 80 81 ld r24, Z
|
|
366: 85 fd sbrc r24, 5
|
|
368: 05 c0 rjmp .+10 ; 0x374 <HardwareSerial::flush()+0x20>
|
|
36a: a8 89 ldd r26, Y+16 ; 0x10
|
|
36c: b9 89 ldd r27, Y+17 ; 0x11
|
|
36e: 8c 91 ld r24, X
|
|
370: 86 fd sbrc r24, 6
|
|
372: 0f c0 rjmp .+30 ; 0x392 <HardwareSerial::flush()+0x3e>
|
|
if (bit_is_clear(SREG, SREG_I) && bit_is_set(*_ucsrb, UDRIE0))
|
|
374: 0f b6 in r0, 0x3f ; 63
|
|
376: 07 fc sbrc r0, 7
|
|
378: f5 cf rjmp .-22 ; 0x364 <HardwareSerial::flush()+0x10>
|
|
37a: 80 81 ld r24, Z
|
|
37c: 85 ff sbrs r24, 5
|
|
37e: f2 cf rjmp .-28 ; 0x364 <HardwareSerial::flush()+0x10>
|
|
// Interrupts are globally disabled, but the DR empty
|
|
// interrupt should be enabled, so poll the DR empty flag to
|
|
// prevent deadlock
|
|
if (bit_is_set(*_ucsra, UDRE0))
|
|
380: a8 89 ldd r26, Y+16 ; 0x10
|
|
382: b9 89 ldd r27, Y+17 ; 0x11
|
|
384: 8c 91 ld r24, X
|
|
386: 85 ff sbrs r24, 5
|
|
388: ed cf rjmp .-38 ; 0x364 <HardwareSerial::flush()+0x10>
|
|
_tx_udr_empty_irq();
|
|
38a: ce 01 movw r24, r28
|
|
38c: 0e 94 42 01 call 0x284 ; 0x284 <HardwareSerial::_tx_udr_empty_irq()>
|
|
390: e7 cf rjmp .-50 ; 0x360 <HardwareSerial::flush()+0xc>
|
|
}
|
|
// If we get here, nothing is queued anymore (DRIE is disabled) and
|
|
// the hardware finished tranmission (TXC is set).
|
|
}
|
|
392: df 91 pop r29
|
|
394: cf 91 pop r28
|
|
396: 08 95 ret
|
|
|
|
00000398 <serialEventRun()>:
|
|
#endif
|
|
|
|
void serialEventRun(void)
|
|
{
|
|
#if defined(HAVE_HWSERIAL0)
|
|
if (Serial0_available && serialEvent && Serial0_available()) serialEvent();
|
|
398: 80 e0 ldi r24, 0x00 ; 0
|
|
39a: 90 e0 ldi r25, 0x00 ; 0
|
|
39c: 89 2b or r24, r25
|
|
39e: 29 f0 breq .+10 ; 0x3aa <serialEventRun()+0x12>
|
|
3a0: 0e 94 38 01 call 0x270 ; 0x270 <Serial0_available()>
|
|
3a4: 81 11 cpse r24, r1
|
|
3a6: 0c 94 00 00 jmp 0 ; 0x0 <__vectors>
|
|
3aa: 08 95 ret
|
|
|
|
000003ac <turnOffPWM>:
|
|
//
|
|
//static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline));
|
|
//static inline void turnOffPWM(uint8_t timer)
|
|
static void turnOffPWM(uint8_t timer)
|
|
{
|
|
switch (timer)
|
|
3ac: 83 30 cpi r24, 0x03 ; 3
|
|
3ae: 81 f0 breq .+32 ; 0x3d0 <turnOffPWM+0x24>
|
|
3b0: 28 f4 brcc .+10 ; 0x3bc <turnOffPWM+0x10>
|
|
3b2: 81 30 cpi r24, 0x01 ; 1
|
|
3b4: 99 f0 breq .+38 ; 0x3dc <turnOffPWM+0x30>
|
|
3b6: 82 30 cpi r24, 0x02 ; 2
|
|
3b8: a1 f0 breq .+40 ; 0x3e2 <turnOffPWM+0x36>
|
|
3ba: 08 95 ret
|
|
3bc: 87 30 cpi r24, 0x07 ; 7
|
|
3be: a9 f0 breq .+42 ; 0x3ea <turnOffPWM+0x3e>
|
|
3c0: 88 30 cpi r24, 0x08 ; 8
|
|
3c2: b9 f0 breq .+46 ; 0x3f2 <turnOffPWM+0x46>
|
|
3c4: 84 30 cpi r24, 0x04 ; 4
|
|
3c6: d1 f4 brne .+52 ; 0x3fc <turnOffPWM+0x50>
|
|
{
|
|
#if defined(TCCR1A) && defined(COM1A1)
|
|
case TIMER1A: cbi(TCCR1A, COM1A1); break;
|
|
#endif
|
|
#if defined(TCCR1A) && defined(COM1B1)
|
|
case TIMER1B: cbi(TCCR1A, COM1B1); break;
|
|
3c8: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080>
|
|
3cc: 8f 7d andi r24, 0xDF ; 223
|
|
3ce: 03 c0 rjmp .+6 ; 0x3d6 <turnOffPWM+0x2a>
|
|
static void turnOffPWM(uint8_t timer)
|
|
{
|
|
switch (timer)
|
|
{
|
|
#if defined(TCCR1A) && defined(COM1A1)
|
|
case TIMER1A: cbi(TCCR1A, COM1A1); break;
|
|
3d0: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080>
|
|
3d4: 8f 77 andi r24, 0x7F ; 127
|
|
#endif
|
|
#if defined(TCCR1A) && defined(COM1B1)
|
|
case TIMER1B: cbi(TCCR1A, COM1B1); break;
|
|
3d6: 80 93 80 00 sts 0x0080, r24 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080>
|
|
3da: 08 95 ret
|
|
#if defined(TCCR2) && defined(COM21)
|
|
case TIMER2: cbi(TCCR2, COM21); break;
|
|
#endif
|
|
|
|
#if defined(TCCR0A) && defined(COM0A1)
|
|
case TIMER0A: cbi(TCCR0A, COM0A1); break;
|
|
3dc: 84 b5 in r24, 0x24 ; 36
|
|
3de: 8f 77 andi r24, 0x7F ; 127
|
|
3e0: 02 c0 rjmp .+4 ; 0x3e6 <turnOffPWM+0x3a>
|
|
#endif
|
|
|
|
#if defined(TCCR0A) && defined(COM0B1)
|
|
case TIMER0B: cbi(TCCR0A, COM0B1); break;
|
|
3e2: 84 b5 in r24, 0x24 ; 36
|
|
3e4: 8f 7d andi r24, 0xDF ; 223
|
|
3e6: 84 bd out 0x24, r24 ; 36
|
|
3e8: 08 95 ret
|
|
#endif
|
|
#if defined(TCCR2A) && defined(COM2A1)
|
|
case TIMER2A: cbi(TCCR2A, COM2A1); break;
|
|
3ea: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0>
|
|
3ee: 8f 77 andi r24, 0x7F ; 127
|
|
3f0: 03 c0 rjmp .+6 ; 0x3f8 <turnOffPWM+0x4c>
|
|
#endif
|
|
#if defined(TCCR2A) && defined(COM2B1)
|
|
case TIMER2B: cbi(TCCR2A, COM2B1); break;
|
|
3f2: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0>
|
|
3f6: 8f 7d andi r24, 0xDF ; 223
|
|
3f8: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0>
|
|
3fc: 08 95 ret
|
|
|
|
000003fe <digitalRead>:
|
|
|
|
SREG = oldSREG;
|
|
}
|
|
|
|
int digitalRead(uint8_t pin)
|
|
{
|
|
3fe: cf 93 push r28
|
|
400: df 93 push r29
|
|
uint8_t timer = digitalPinToTimer(pin);
|
|
402: 28 2f mov r18, r24
|
|
404: 30 e0 ldi r19, 0x00 ; 0
|
|
406: f9 01 movw r30, r18
|
|
408: e2 55 subi r30, 0x52 ; 82
|
|
40a: ff 4f sbci r31, 0xFF ; 255
|
|
40c: 84 91 lpm r24, Z
|
|
uint8_t bit = digitalPinToBitMask(pin);
|
|
40e: f9 01 movw r30, r18
|
|
410: e6 56 subi r30, 0x66 ; 102
|
|
412: ff 4f sbci r31, 0xFF ; 255
|
|
414: d4 91 lpm r29, Z
|
|
uint8_t port = digitalPinToPort(pin);
|
|
416: f9 01 movw r30, r18
|
|
418: ea 57 subi r30, 0x7A ; 122
|
|
41a: ff 4f sbci r31, 0xFF ; 255
|
|
41c: c4 91 lpm r28, Z
|
|
|
|
if (port == NOT_A_PIN) return LOW;
|
|
41e: cc 23 and r28, r28
|
|
420: 91 f0 breq .+36 ; 0x446 <__LOCK_REGION_LENGTH__+0x46>
|
|
|
|
// If the pin that support PWM output, we need to turn it off
|
|
// before getting a digital reading.
|
|
if (timer != NOT_ON_TIMER) turnOffPWM(timer);
|
|
422: 81 11 cpse r24, r1
|
|
424: 0e 94 d6 01 call 0x3ac ; 0x3ac <turnOffPWM>
|
|
|
|
if (*portInputRegister(port) & bit) return HIGH;
|
|
428: ec 2f mov r30, r28
|
|
42a: f0 e0 ldi r31, 0x00 ; 0
|
|
42c: ee 0f add r30, r30
|
|
42e: ff 1f adc r31, r31
|
|
430: e4 58 subi r30, 0x84 ; 132
|
|
432: ff 4f sbci r31, 0xFF ; 255
|
|
434: a5 91 lpm r26, Z+
|
|
436: b4 91 lpm r27, Z
|
|
438: ec 91 ld r30, X
|
|
43a: ed 23 and r30, r29
|
|
43c: 81 e0 ldi r24, 0x01 ; 1
|
|
43e: 90 e0 ldi r25, 0x00 ; 0
|
|
440: 21 f4 brne .+8 ; 0x44a <__LOCK_REGION_LENGTH__+0x4a>
|
|
442: 80 e0 ldi r24, 0x00 ; 0
|
|
444: 02 c0 rjmp .+4 ; 0x44a <__LOCK_REGION_LENGTH__+0x4a>
|
|
{
|
|
uint8_t timer = digitalPinToTimer(pin);
|
|
uint8_t bit = digitalPinToBitMask(pin);
|
|
uint8_t port = digitalPinToPort(pin);
|
|
|
|
if (port == NOT_A_PIN) return LOW;
|
|
446: 80 e0 ldi r24, 0x00 ; 0
|
|
448: 90 e0 ldi r25, 0x00 ; 0
|
|
// before getting a digital reading.
|
|
if (timer != NOT_ON_TIMER) turnOffPWM(timer);
|
|
|
|
if (*portInputRegister(port) & bit) return HIGH;
|
|
return LOW;
|
|
}
|
|
44a: df 91 pop r29
|
|
44c: cf 91 pop r28
|
|
44e: 08 95 ret
|
|
|
|
00000450 <digitalWrite>:
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void digitalWrite(uint8_t pin, uint8_t val)
|
|
{
|
|
450: 1f 93 push r17
|
|
452: cf 93 push r28
|
|
454: df 93 push r29
|
|
uint8_t timer = digitalPinToTimer(pin);
|
|
456: 28 2f mov r18, r24
|
|
458: 30 e0 ldi r19, 0x00 ; 0
|
|
45a: f9 01 movw r30, r18
|
|
45c: e2 55 subi r30, 0x52 ; 82
|
|
45e: ff 4f sbci r31, 0xFF ; 255
|
|
460: 84 91 lpm r24, Z
|
|
uint8_t bit = digitalPinToBitMask(pin);
|
|
462: f9 01 movw r30, r18
|
|
464: e6 56 subi r30, 0x66 ; 102
|
|
466: ff 4f sbci r31, 0xFF ; 255
|
|
468: d4 91 lpm r29, Z
|
|
uint8_t port = digitalPinToPort(pin);
|
|
46a: f9 01 movw r30, r18
|
|
46c: ea 57 subi r30, 0x7A ; 122
|
|
46e: ff 4f sbci r31, 0xFF ; 255
|
|
470: c4 91 lpm r28, Z
|
|
volatile uint8_t *out;
|
|
|
|
if (port == NOT_A_PIN) return;
|
|
472: cc 23 and r28, r28
|
|
474: c9 f0 breq .+50 ; 0x4a8 <digitalWrite+0x58>
|
|
476: 16 2f mov r17, r22
|
|
|
|
// If the pin that support PWM output, we need to turn it off
|
|
// before doing a digital write.
|
|
if (timer != NOT_ON_TIMER) turnOffPWM(timer);
|
|
478: 81 11 cpse r24, r1
|
|
47a: 0e 94 d6 01 call 0x3ac ; 0x3ac <turnOffPWM>
|
|
|
|
out = portOutputRegister(port);
|
|
47e: ec 2f mov r30, r28
|
|
480: f0 e0 ldi r31, 0x00 ; 0
|
|
482: ee 0f add r30, r30
|
|
484: ff 1f adc r31, r31
|
|
486: ee 58 subi r30, 0x8E ; 142
|
|
488: ff 4f sbci r31, 0xFF ; 255
|
|
48a: a5 91 lpm r26, Z+
|
|
48c: b4 91 lpm r27, Z
|
|
|
|
uint8_t oldSREG = SREG;
|
|
48e: 8f b7 in r24, 0x3f ; 63
|
|
cli();
|
|
490: f8 94 cli
|
|
|
|
if (val == LOW) {
|
|
492: 11 11 cpse r17, r1
|
|
494: 05 c0 rjmp .+10 ; 0x4a0 <digitalWrite+0x50>
|
|
*out &= ~bit;
|
|
496: 9c 91 ld r25, X
|
|
498: ed 2f mov r30, r29
|
|
49a: e0 95 com r30
|
|
49c: e9 23 and r30, r25
|
|
49e: 02 c0 rjmp .+4 ; 0x4a4 <digitalWrite+0x54>
|
|
} else {
|
|
*out |= bit;
|
|
4a0: ec 91 ld r30, X
|
|
4a2: ed 2b or r30, r29
|
|
4a4: ec 93 st X, r30
|
|
}
|
|
|
|
SREG = oldSREG;
|
|
4a6: 8f bf out 0x3f, r24 ; 63
|
|
}
|
|
4a8: df 91 pop r29
|
|
4aa: cf 91 pop r28
|
|
4ac: 1f 91 pop r17
|
|
4ae: 08 95 ret
|
|
|
|
000004b0 <pinMode>:
|
|
#define ARDUINO_MAIN
|
|
#include "wiring_private.h"
|
|
#include "pins_arduino.h"
|
|
|
|
void pinMode(uint8_t pin, uint8_t mode)
|
|
{
|
|
4b0: cf 93 push r28
|
|
4b2: df 93 push r29
|
|
uint8_t bit = digitalPinToBitMask(pin);
|
|
4b4: 90 e0 ldi r25, 0x00 ; 0
|
|
4b6: fc 01 movw r30, r24
|
|
4b8: e6 56 subi r30, 0x66 ; 102
|
|
4ba: ff 4f sbci r31, 0xFF ; 255
|
|
4bc: 24 91 lpm r18, Z
|
|
uint8_t port = digitalPinToPort(pin);
|
|
4be: fc 01 movw r30, r24
|
|
4c0: ea 57 subi r30, 0x7A ; 122
|
|
4c2: ff 4f sbci r31, 0xFF ; 255
|
|
4c4: 84 91 lpm r24, Z
|
|
volatile uint8_t *reg, *out;
|
|
|
|
if (port == NOT_A_PIN) return;
|
|
4c6: 88 23 and r24, r24
|
|
4c8: 61 f1 breq .+88 ; 0x522 <pinMode+0x72>
|
|
|
|
// JWS: can I let the optimizer do this?
|
|
reg = portModeRegister(port);
|
|
4ca: 90 e0 ldi r25, 0x00 ; 0
|
|
4cc: 88 0f add r24, r24
|
|
4ce: 99 1f adc r25, r25
|
|
4d0: fc 01 movw r30, r24
|
|
4d2: e8 59 subi r30, 0x98 ; 152
|
|
4d4: ff 4f sbci r31, 0xFF ; 255
|
|
4d6: c5 91 lpm r28, Z+
|
|
4d8: d4 91 lpm r29, Z
|
|
out = portOutputRegister(port);
|
|
4da: fc 01 movw r30, r24
|
|
4dc: ee 58 subi r30, 0x8E ; 142
|
|
4de: ff 4f sbci r31, 0xFF ; 255
|
|
4e0: a5 91 lpm r26, Z+
|
|
4e2: b4 91 lpm r27, Z
|
|
|
|
if (mode == INPUT) {
|
|
4e4: 61 11 cpse r22, r1
|
|
4e6: 09 c0 rjmp .+18 ; 0x4fa <pinMode+0x4a>
|
|
uint8_t oldSREG = SREG;
|
|
4e8: 9f b7 in r25, 0x3f ; 63
|
|
cli();
|
|
4ea: f8 94 cli
|
|
*reg &= ~bit;
|
|
4ec: 88 81 ld r24, Y
|
|
4ee: 20 95 com r18
|
|
4f0: 82 23 and r24, r18
|
|
4f2: 88 83 st Y, r24
|
|
*out &= ~bit;
|
|
4f4: ec 91 ld r30, X
|
|
4f6: 2e 23 and r18, r30
|
|
4f8: 0b c0 rjmp .+22 ; 0x510 <pinMode+0x60>
|
|
SREG = oldSREG;
|
|
} else if (mode == INPUT_PULLUP) {
|
|
4fa: 62 30 cpi r22, 0x02 ; 2
|
|
4fc: 61 f4 brne .+24 ; 0x516 <pinMode+0x66>
|
|
uint8_t oldSREG = SREG;
|
|
4fe: 9f b7 in r25, 0x3f ; 63
|
|
cli();
|
|
500: f8 94 cli
|
|
*reg &= ~bit;
|
|
502: 38 81 ld r19, Y
|
|
504: 82 2f mov r24, r18
|
|
506: 80 95 com r24
|
|
508: 83 23 and r24, r19
|
|
50a: 88 83 st Y, r24
|
|
*out |= bit;
|
|
50c: ec 91 ld r30, X
|
|
50e: 2e 2b or r18, r30
|
|
510: 2c 93 st X, r18
|
|
SREG = oldSREG;
|
|
512: 9f bf out 0x3f, r25 ; 63
|
|
514: 06 c0 rjmp .+12 ; 0x522 <pinMode+0x72>
|
|
} else {
|
|
uint8_t oldSREG = SREG;
|
|
516: 8f b7 in r24, 0x3f ; 63
|
|
cli();
|
|
518: f8 94 cli
|
|
*reg |= bit;
|
|
51a: e8 81 ld r30, Y
|
|
51c: 2e 2b or r18, r30
|
|
51e: 28 83 st Y, r18
|
|
SREG = oldSREG;
|
|
520: 8f bf out 0x3f, r24 ; 63
|
|
}
|
|
}
|
|
522: df 91 pop r29
|
|
524: cf 91 pop r28
|
|
526: 08 95 ret
|
|
|
|
00000528 <micros>:
|
|
return m;
|
|
}
|
|
|
|
unsigned long micros() {
|
|
unsigned long m;
|
|
uint8_t oldSREG = SREG, t;
|
|
528: 3f b7 in r19, 0x3f ; 63
|
|
|
|
cli();
|
|
52a: f8 94 cli
|
|
m = timer0_overflow_count;
|
|
52c: 80 91 1d 01 lds r24, 0x011D ; 0x80011d <timer0_overflow_count>
|
|
530: 90 91 1e 01 lds r25, 0x011E ; 0x80011e <timer0_overflow_count+0x1>
|
|
534: a0 91 1f 01 lds r26, 0x011F ; 0x80011f <timer0_overflow_count+0x2>
|
|
538: b0 91 20 01 lds r27, 0x0120 ; 0x800120 <timer0_overflow_count+0x3>
|
|
#if defined(TCNT0)
|
|
t = TCNT0;
|
|
53c: 26 b5 in r18, 0x26 ; 38
|
|
#else
|
|
#error TIMER 0 not defined
|
|
#endif
|
|
|
|
#ifdef TIFR0
|
|
if ((TIFR0 & _BV(TOV0)) && (t < 255))
|
|
53e: a8 9b sbis 0x15, 0 ; 21
|
|
540: 05 c0 rjmp .+10 ; 0x54c <micros+0x24>
|
|
542: 2f 3f cpi r18, 0xFF ; 255
|
|
544: 19 f0 breq .+6 ; 0x54c <micros+0x24>
|
|
m++;
|
|
546: 01 96 adiw r24, 0x01 ; 1
|
|
548: a1 1d adc r26, r1
|
|
54a: b1 1d adc r27, r1
|
|
#else
|
|
if ((TIFR & _BV(TOV0)) && (t < 255))
|
|
m++;
|
|
#endif
|
|
|
|
SREG = oldSREG;
|
|
54c: 3f bf out 0x3f, r19 ; 63
|
|
|
|
return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond());
|
|
54e: ba 2f mov r27, r26
|
|
550: a9 2f mov r26, r25
|
|
552: 98 2f mov r25, r24
|
|
554: 88 27 eor r24, r24
|
|
556: 82 0f add r24, r18
|
|
558: 91 1d adc r25, r1
|
|
55a: a1 1d adc r26, r1
|
|
55c: b1 1d adc r27, r1
|
|
55e: bc 01 movw r22, r24
|
|
560: cd 01 movw r24, r26
|
|
562: 42 e0 ldi r20, 0x02 ; 2
|
|
564: 66 0f add r22, r22
|
|
566: 77 1f adc r23, r23
|
|
568: 88 1f adc r24, r24
|
|
56a: 99 1f adc r25, r25
|
|
56c: 4a 95 dec r20
|
|
56e: d1 f7 brne .-12 ; 0x564 <micros+0x3c>
|
|
}
|
|
570: 08 95 ret
|
|
|
|
00000572 <checkCLKandBIN()>:
|
|
|
|
|
|
|
|
//sample on falling edge (middle of bit)
|
|
}
|
|
void checkCLKandBIN(void){
|
|
572: 0f 93 push r16
|
|
574: 1f 93 push r17
|
|
576: cf 93 push r28
|
|
578: df 93 push r29
|
|
|
|
|
|
#endif
|
|
|
|
// busy wait
|
|
__asm__ __volatile__ (
|
|
57a: 03 e2 ldi r16, 0x23 ; 35
|
|
57c: 10 e0 ldi r17, 0x00 ; 0
|
|
* clk++
|
|
* sample hzbinary
|
|
* while clk low do nothing
|
|
*/
|
|
//milliscompare = millis();
|
|
while((hzclkval = digitalRead(hzclk)) == HIGH){
|
|
57e: 87 e0 ldi r24, 0x07 ; 7
|
|
580: 0e 94 ff 01 call 0x3fe ; 0x3fe <digitalRead>
|
|
584: d8 2f mov r29, r24
|
|
586: 80 93 16 01 sts 0x0116, r24 ; 0x800116 <__data_end>
|
|
58a: 81 30 cpi r24, 0x01 ; 1
|
|
58c: b9 f4 brne .+46 ; 0x5bc <checkCLKandBIN()+0x4a>
|
|
if(readyet == 0){
|
|
58e: 80 91 17 01 lds r24, 0x0117 ; 0x800117 <readyet>
|
|
592: 81 11 cpse r24, r1
|
|
594: 0f c0 rjmp .+30 ; 0x5b4 <checkCLKandBIN()+0x42>
|
|
hzbinval[clkval] = digitalRead(hzbinary);
|
|
596: c0 91 46 01 lds r28, 0x0146 ; 0x800146 <clkval>
|
|
59a: 86 e0 ldi r24, 0x06 ; 6
|
|
59c: 0e 94 ff 01 call 0x3fe ; 0x3fe <digitalRead>
|
|
5a0: ec 2f mov r30, r28
|
|
5a2: f0 e0 ldi r31, 0x00 ; 0
|
|
5a4: ed 5d subi r30, 0xDD ; 221
|
|
5a6: fe 4f sbci r31, 0xFE ; 254
|
|
5a8: 80 83 st Z, r24
|
|
clkval++;
|
|
5aa: cf 5f subi r28, 0xFF ; 255
|
|
5ac: c0 93 46 01 sts 0x0146, r28 ; 0x800146 <clkval>
|
|
readyet = 1;
|
|
5b0: d0 93 17 01 sts 0x0117, r29 ; 0x800117 <readyet>
|
|
5b4: c8 01 movw r24, r16
|
|
5b6: 01 97 sbiw r24, 0x01 ; 1
|
|
5b8: f1 f7 brne .-4 ; 0x5b6 <checkCLKandBIN()+0x44>
|
|
5ba: e1 cf rjmp .-62 ; 0x57e <checkCLKandBIN()+0xc>
|
|
}
|
|
delayMicroseconds(10);
|
|
}
|
|
while((hzclkval = digitalRead(hzclk)) == LOW){
|
|
5bc: 87 e0 ldi r24, 0x07 ; 7
|
|
5be: 0e 94 ff 01 call 0x3fe ; 0x3fe <digitalRead>
|
|
5c2: 80 93 16 01 sts 0x0116, r24 ; 0x800116 <__data_end>
|
|
5c6: 81 11 cpse r24, r1
|
|
5c8: 03 c0 rjmp .+6 ; 0x5d0 <checkCLKandBIN()+0x5e>
|
|
delayMicroseconds(1);
|
|
readyet = 0;
|
|
5ca: 10 92 17 01 sts 0x0117, r1 ; 0x800117 <readyet>
|
|
5ce: f6 cf rjmp .-20 ; 0x5bc <checkCLKandBIN()+0x4a>
|
|
|
|
//would be nice to add a picture to this source code (waveform)
|
|
//or oscope picture
|
|
//why isn't this possible?
|
|
|
|
}
|
|
5d0: df 91 pop r29
|
|
5d2: cf 91 pop r28
|
|
5d4: 1f 91 pop r17
|
|
5d6: 0f 91 pop r16
|
|
5d8: 08 95 ret
|
|
|
|
000005da <LedControl::spiTransfer(int, unsigned char, unsigned char)>:
|
|
v|=B10000000;
|
|
status[offset+digit]=v;
|
|
spiTransfer(addr, digit+1,v);
|
|
}
|
|
|
|
void LedControl::spiTransfer(int addr, volatile byte opcode, volatile byte data) {
|
|
5da: 2f 92 push r2
|
|
5dc: 3f 92 push r3
|
|
5de: 4f 92 push r4
|
|
5e0: 5f 92 push r5
|
|
5e2: 6f 92 push r6
|
|
5e4: 7f 92 push r7
|
|
5e6: 8f 92 push r8
|
|
5e8: 9f 92 push r9
|
|
5ea: af 92 push r10
|
|
5ec: bf 92 push r11
|
|
5ee: cf 92 push r12
|
|
5f0: df 92 push r13
|
|
5f2: ef 92 push r14
|
|
5f4: ff 92 push r15
|
|
5f6: 0f 93 push r16
|
|
5f8: 1f 93 push r17
|
|
5fa: cf 93 push r28
|
|
5fc: df 93 push r29
|
|
5fe: 00 d0 rcall .+0 ; 0x600 <LedControl::spiTransfer(int, unsigned char, unsigned char)+0x26>
|
|
600: cd b7 in r28, 0x3d ; 61
|
|
602: de b7 in r29, 0x3e ; 62
|
|
604: 8c 01 movw r16, r24
|
|
606: 49 83 std Y+1, r20 ; 0x01
|
|
608: 2a 83 std Y+2, r18 ; 0x02
|
|
//Create an array with the data to shift out
|
|
int offset=addr*2;
|
|
60a: 66 0f add r22, r22
|
|
60c: 77 1f adc r23, r23
|
|
int maxbytes=maxDevices*2;
|
|
60e: f8 01 movw r30, r16
|
|
610: ea 5a subi r30, 0xAA ; 170
|
|
612: ff 4f sbci r31, 0xFF ; 255
|
|
614: e0 80 ld r14, Z
|
|
616: f1 80 ldd r15, Z+1 ; 0x01
|
|
618: ee 0c add r14, r14
|
|
61a: ff 1c adc r15, r15
|
|
61c: f8 01 movw r30, r16
|
|
61e: cf 01 movw r24, r30
|
|
620: 80 1b sub r24, r16
|
|
622: 91 0b sbc r25, r17
|
|
|
|
for(int i=0;i<maxbytes;i++)
|
|
624: 8e 15 cp r24, r14
|
|
626: 9f 05 cpc r25, r15
|
|
628: 14 f4 brge .+4 ; 0x62e <LedControl::spiTransfer(int, unsigned char, unsigned char)+0x54>
|
|
spidata[i]=(byte)0;
|
|
62a: 11 92 st Z+, r1
|
|
62c: f8 cf rjmp .-16 ; 0x61e <LedControl::spiTransfer(int, unsigned char, unsigned char)+0x44>
|
|
//put our device data into the array
|
|
spidata[offset+1]=opcode;
|
|
62e: 89 81 ldd r24, Y+1 ; 0x01
|
|
630: f8 01 movw r30, r16
|
|
632: e6 0f add r30, r22
|
|
634: f7 1f adc r31, r23
|
|
636: 81 83 std Z+1, r24 ; 0x01
|
|
spidata[offset]=data;
|
|
638: 8a 81 ldd r24, Y+2 ; 0x02
|
|
63a: 80 83 st Z, r24
|
|
//enable the line
|
|
digitalWrite(SPI_CS,LOW);
|
|
63c: 58 01 movw r10, r16
|
|
63e: 84 e5 ldi r24, 0x54 ; 84
|
|
640: a8 0e add r10, r24
|
|
642: b1 1c adc r11, r1
|
|
644: 60 e0 ldi r22, 0x00 ; 0
|
|
646: f5 01 movw r30, r10
|
|
648: 80 81 ld r24, Z
|
|
64a: 0e 94 28 02 call 0x450 ; 0x450 <digitalWrite>
|
|
64e: e0 0e add r14, r16
|
|
650: f1 1e adc r15, r17
|
|
//Now shift out the data
|
|
for(int i=maxbytes;i>0;i--)
|
|
shiftOut(SPI_MOSI,SPI_CLK,MSBFIRST,spidata[i-1]);
|
|
652: 48 01 movw r8, r16
|
|
654: f2 e5 ldi r31, 0x52 ; 82
|
|
656: 8f 0e add r8, r31
|
|
658: 91 1c adc r9, r1
|
|
65a: 38 01 movw r6, r16
|
|
65c: 80 e5 ldi r24, 0x50 ; 80
|
|
65e: 68 0e add r6, r24
|
|
660: 71 1c adc r7, r1
|
|
662: c7 01 movw r24, r14
|
|
664: 80 1b sub r24, r16
|
|
666: 91 0b sbc r25, r17
|
|
spidata[offset+1]=opcode;
|
|
spidata[offset]=data;
|
|
//enable the line
|
|
digitalWrite(SPI_CS,LOW);
|
|
//Now shift out the data
|
|
for(int i=maxbytes;i>0;i--)
|
|
668: 18 16 cp r1, r24
|
|
66a: 19 06 cpc r1, r25
|
|
66c: 24 f5 brge .+72 ; 0x6b6 <LedControl::spiTransfer(int, unsigned char, unsigned char)+0xdc>
|
|
shiftOut(SPI_MOSI,SPI_CLK,MSBFIRST,spidata[i-1]);
|
|
66e: f7 01 movw r30, r14
|
|
670: c2 90 ld r12, -Z
|
|
672: 7f 01 movw r14, r30
|
|
674: f4 01 movw r30, r8
|
|
676: 30 80 ld r3, Z
|
|
678: f3 01 movw r30, r6
|
|
67a: 20 80 ld r2, Z
|
|
67c: 87 e0 ldi r24, 0x07 ; 7
|
|
67e: 48 2e mov r4, r24
|
|
680: 51 2c mov r5, r1
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
if (bitOrder == LSBFIRST)
|
|
digitalWrite(dataPin, !!(val & (1 << i)));
|
|
else
|
|
digitalWrite(dataPin, !!(val & (1 << (7 - i))));
|
|
682: d1 2c mov r13, r1
|
|
684: b6 01 movw r22, r12
|
|
686: 04 2c mov r0, r4
|
|
688: 02 c0 rjmp .+4 ; 0x68e <LedControl::spiTransfer(int, unsigned char, unsigned char)+0xb4>
|
|
68a: 75 95 asr r23
|
|
68c: 67 95 ror r22
|
|
68e: 0a 94 dec r0
|
|
690: e2 f7 brpl .-8 ; 0x68a <LedControl::spiTransfer(int, unsigned char, unsigned char)+0xb0>
|
|
692: 61 70 andi r22, 0x01 ; 1
|
|
694: 77 27 eor r23, r23
|
|
696: 82 2d mov r24, r2
|
|
698: 0e 94 28 02 call 0x450 ; 0x450 <digitalWrite>
|
|
|
|
digitalWrite(clockPin, HIGH);
|
|
69c: 61 e0 ldi r22, 0x01 ; 1
|
|
69e: 83 2d mov r24, r3
|
|
6a0: 0e 94 28 02 call 0x450 ; 0x450 <digitalWrite>
|
|
digitalWrite(clockPin, LOW);
|
|
6a4: 60 e0 ldi r22, 0x00 ; 0
|
|
6a6: 83 2d mov r24, r3
|
|
6a8: 0e 94 28 02 call 0x450 ; 0x450 <digitalWrite>
|
|
6ac: f1 e0 ldi r31, 0x01 ; 1
|
|
6ae: 4f 1a sub r4, r31
|
|
6b0: 51 08 sbc r5, r1
|
|
6b2: 40 f7 brcc .-48 ; 0x684 <LedControl::spiTransfer(int, unsigned char, unsigned char)+0xaa>
|
|
6b4: d6 cf rjmp .-84 ; 0x662 <LedControl::spiTransfer(int, unsigned char, unsigned char)+0x88>
|
|
//latch the data onto the display
|
|
digitalWrite(SPI_CS,HIGH);
|
|
6b6: 61 e0 ldi r22, 0x01 ; 1
|
|
6b8: f5 01 movw r30, r10
|
|
6ba: 80 81 ld r24, Z
|
|
}
|
|
6bc: 0f 90 pop r0
|
|
6be: 0f 90 pop r0
|
|
6c0: df 91 pop r29
|
|
6c2: cf 91 pop r28
|
|
6c4: 1f 91 pop r17
|
|
6c6: 0f 91 pop r16
|
|
6c8: ff 90 pop r15
|
|
6ca: ef 90 pop r14
|
|
6cc: df 90 pop r13
|
|
6ce: cf 90 pop r12
|
|
6d0: bf 90 pop r11
|
|
6d2: af 90 pop r10
|
|
6d4: 9f 90 pop r9
|
|
6d6: 8f 90 pop r8
|
|
6d8: 7f 90 pop r7
|
|
6da: 6f 90 pop r6
|
|
6dc: 5f 90 pop r5
|
|
6de: 4f 90 pop r4
|
|
6e0: 3f 90 pop r3
|
|
6e2: 2f 90 pop r2
|
|
digitalWrite(SPI_CS,LOW);
|
|
//Now shift out the data
|
|
for(int i=maxbytes;i>0;i--)
|
|
shiftOut(SPI_MOSI,SPI_CLK,MSBFIRST,spidata[i-1]);
|
|
//latch the data onto the display
|
|
digitalWrite(SPI_CS,HIGH);
|
|
6e4: 0c 94 28 02 jmp 0x450 ; 0x450 <digitalWrite>
|
|
|
|
000006e8 <LedControl::setDigit(int, int, unsigned char, bool) [clone .constprop.15]>:
|
|
|
|
void LedControl::setDigit(int addr, int digit, byte value, boolean dp) {
|
|
int offset;
|
|
byte v;
|
|
|
|
if(addr<0 || addr>=maxDevices)
|
|
6e8: 20 91 3a 02 lds r18, 0x023A ; 0x80023a <lc+0x56>
|
|
6ec: 30 91 3b 02 lds r19, 0x023B ; 0x80023b <lc+0x57>
|
|
6f0: 12 16 cp r1, r18
|
|
6f2: 13 06 cpc r1, r19
|
|
6f4: b4 f4 brge .+44 ; 0x722 <LedControl::setDigit(int, int, unsigned char, bool) [clone .constprop.15]+0x3a>
|
|
return;
|
|
if(digit<0 || digit>7 || value>15)
|
|
6f6: 88 30 cpi r24, 0x08 ; 8
|
|
6f8: 91 05 cpc r25, r1
|
|
6fa: 98 f4 brcc .+38 ; 0x722 <LedControl::setDigit(int, int, unsigned char, bool) [clone .constprop.15]+0x3a>
|
|
6fc: 60 31 cpi r22, 0x10 ; 16
|
|
6fe: 88 f4 brcc .+34 ; 0x722 <LedControl::setDigit(int, int, unsigned char, bool) [clone .constprop.15]+0x3a>
|
|
return;
|
|
offset=addr*8;
|
|
v=pgm_read_byte_near(charTable + value);
|
|
700: e6 2f mov r30, r22
|
|
702: f0 e0 ldi r31, 0x00 ; 0
|
|
704: ee 53 subi r30, 0x3E ; 62
|
|
706: ff 4f sbci r31, 0xFF ; 255
|
|
708: 24 91 lpm r18, Z
|
|
if(dp)
|
|
v|=B10000000;
|
|
status[offset+digit]=v;
|
|
70a: fc 01 movw r30, r24
|
|
70c: ec 51 subi r30, 0x1C ; 28
|
|
70e: fe 4f sbci r31, 0xFE ; 254
|
|
710: 20 8b std Z+16, r18 ; 0x10
|
|
spiTransfer(addr, digit+1,v);
|
|
712: 41 e0 ldi r20, 0x01 ; 1
|
|
714: 48 0f add r20, r24
|
|
716: 60 e0 ldi r22, 0x00 ; 0
|
|
718: 70 e0 ldi r23, 0x00 ; 0
|
|
71a: 84 ee ldi r24, 0xE4 ; 228
|
|
71c: 91 e0 ldi r25, 0x01 ; 1
|
|
71e: 0c 94 ed 02 jmp 0x5da ; 0x5da <LedControl::spiTransfer(int, unsigned char, unsigned char)>
|
|
722: 08 95 ret
|
|
|
|
00000724 <LedControl::clearDisplay(int)>:
|
|
return;
|
|
if(intensity>=0 && intensity<16)
|
|
spiTransfer(addr, OP_INTENSITY,intensity);
|
|
}
|
|
|
|
void LedControl::clearDisplay(int addr) {
|
|
724: cf 92 push r12
|
|
726: df 92 push r13
|
|
728: ef 92 push r14
|
|
72a: ff 92 push r15
|
|
72c: 0f 93 push r16
|
|
72e: 1f 93 push r17
|
|
730: cf 93 push r28
|
|
732: df 93 push r29
|
|
int offset;
|
|
|
|
if(addr<0 || addr>=maxDevices)
|
|
734: 77 fd sbrc r23, 7
|
|
736: 23 c0 rjmp .+70 ; 0x77e <LedControl::clearDisplay(int)+0x5a>
|
|
738: fc 01 movw r30, r24
|
|
73a: ea 5a subi r30, 0xAA ; 170
|
|
73c: ff 4f sbci r31, 0xFF ; 255
|
|
73e: 20 81 ld r18, Z
|
|
740: 31 81 ldd r19, Z+1 ; 0x01
|
|
742: 62 17 cp r22, r18
|
|
744: 73 07 cpc r23, r19
|
|
746: dc f4 brge .+54 ; 0x77e <LedControl::clearDisplay(int)+0x5a>
|
|
748: eb 01 movw r28, r22
|
|
74a: 7c 01 movw r14, r24
|
|
return;
|
|
offset=addr*8;
|
|
74c: 6b 01 movw r12, r22
|
|
74e: 83 e0 ldi r24, 0x03 ; 3
|
|
750: cc 0c add r12, r12
|
|
752: dd 1c adc r13, r13
|
|
754: 8a 95 dec r24
|
|
756: e1 f7 brne .-8 ; 0x750 <LedControl::clearDisplay(int)+0x2c>
|
|
758: 01 e0 ldi r16, 0x01 ; 1
|
|
75a: 10 e0 ldi r17, 0x00 ; 0
|
|
75c: f8 01 movw r30, r16
|
|
75e: ec 0d add r30, r12
|
|
760: fd 1d adc r31, r13
|
|
762: ee 0d add r30, r14
|
|
764: ff 1d adc r31, r15
|
|
for(int i=0;i<8;i++) {
|
|
status[offset+i]=0;
|
|
766: 17 86 std Z+15, r1 ; 0x0f
|
|
spiTransfer(addr, i+1,status[offset+i]);
|
|
768: 20 e0 ldi r18, 0x00 ; 0
|
|
76a: 40 2f mov r20, r16
|
|
76c: be 01 movw r22, r28
|
|
76e: c7 01 movw r24, r14
|
|
770: 0e 94 ed 02 call 0x5da ; 0x5da <LedControl::spiTransfer(int, unsigned char, unsigned char)>
|
|
774: 0f 5f subi r16, 0xFF ; 255
|
|
776: 1f 4f sbci r17, 0xFF ; 255
|
|
int offset;
|
|
|
|
if(addr<0 || addr>=maxDevices)
|
|
return;
|
|
offset=addr*8;
|
|
for(int i=0;i<8;i++) {
|
|
778: 09 30 cpi r16, 0x09 ; 9
|
|
77a: 11 05 cpc r17, r1
|
|
77c: 79 f7 brne .-34 ; 0x75c <LedControl::clearDisplay(int)+0x38>
|
|
status[offset+i]=0;
|
|
spiTransfer(addr, i+1,status[offset+i]);
|
|
}
|
|
}
|
|
77e: df 91 pop r29
|
|
780: cf 91 pop r28
|
|
782: 1f 91 pop r17
|
|
784: 0f 91 pop r16
|
|
786: ff 90 pop r15
|
|
788: ef 90 pop r14
|
|
78a: df 90 pop r13
|
|
78c: cf 90 pop r12
|
|
78e: 08 95 ret
|
|
|
|
00000790 <Print::write(char const*) [clone .constprop.10]>:
|
|
int getWriteError() { return write_error; }
|
|
void clearWriteError() { setWriteError(0); }
|
|
|
|
virtual size_t write(uint8_t) = 0;
|
|
size_t write(const char *str) {
|
|
if (str == NULL) return 0;
|
|
790: 00 97 sbiw r24, 0x00 ; 0
|
|
792: 69 f0 breq .+26 ; 0x7ae <Print::write(char const*) [clone .constprop.10]+0x1e>
|
|
return write((const uint8_t *)str, strlen(str));
|
|
794: fc 01 movw r30, r24
|
|
796: 01 90 ld r0, Z+
|
|
798: 00 20 and r0, r0
|
|
79a: e9 f7 brne .-6 ; 0x796 <Print::write(char const*) [clone .constprop.10]+0x6>
|
|
79c: 31 97 sbiw r30, 0x01 ; 1
|
|
79e: af 01 movw r20, r30
|
|
7a0: 48 1b sub r20, r24
|
|
7a2: 59 0b sbc r21, r25
|
|
7a4: bc 01 movw r22, r24
|
|
7a6: 87 e4 ldi r24, 0x47 ; 71
|
|
7a8: 91 e0 ldi r25, 0x01 ; 1
|
|
7aa: 0c 94 cc 00 jmp 0x198 ; 0x198 <Print::write(unsigned char const*, unsigned int)>
|
|
}
|
|
7ae: 80 e0 ldi r24, 0x00 ; 0
|
|
7b0: 90 e0 ldi r25, 0x00 ; 0
|
|
7b2: 08 95 ret
|
|
|
|
000007b4 <Print::printNumber(unsigned long, unsigned char) [clone .constprop.7]>:
|
|
return n;
|
|
}
|
|
|
|
// Private Methods /////////////////////////////////////////////////////////////
|
|
|
|
size_t Print::printNumber(unsigned long n, uint8_t base)
|
|
7b4: 8f 92 push r8
|
|
7b6: 9f 92 push r9
|
|
7b8: af 92 push r10
|
|
7ba: bf 92 push r11
|
|
7bc: 0f 93 push r16
|
|
7be: 1f 93 push r17
|
|
7c0: cf 93 push r28
|
|
7c2: df 93 push r29
|
|
7c4: cd b7 in r28, 0x3d ; 61
|
|
7c6: de b7 in r29, 0x3e ; 62
|
|
7c8: a1 97 sbiw r28, 0x21 ; 33
|
|
7ca: 0f b6 in r0, 0x3f ; 63
|
|
7cc: f8 94 cli
|
|
7ce: de bf out 0x3e, r29 ; 62
|
|
7d0: 0f be out 0x3f, r0 ; 63
|
|
7d2: cd bf out 0x3d, r28 ; 61
|
|
{
|
|
char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
|
|
char *str = &buf[sizeof(buf) - 1];
|
|
|
|
*str = '\0';
|
|
7d4: 19 a2 std Y+33, r1 ; 0x21
|
|
|
|
// prevent crash if called with base == 1
|
|
if (base < 2) base = 10;
|
|
7d6: 42 30 cpi r20, 0x02 ; 2
|
|
7d8: 08 f4 brcc .+2 ; 0x7dc <Print::printNumber(unsigned long, unsigned char) [clone .constprop.7]+0x28>
|
|
7da: 4a e0 ldi r20, 0x0A ; 10
|
|
7dc: 8e 01 movw r16, r28
|
|
7de: 0f 5d subi r16, 0xDF ; 223
|
|
7e0: 1f 4f sbci r17, 0xFF ; 255
|
|
|
|
do {
|
|
char c = n % base;
|
|
7e2: 84 2e mov r8, r20
|
|
7e4: 91 2c mov r9, r1
|
|
7e6: a1 2c mov r10, r1
|
|
7e8: b1 2c mov r11, r1
|
|
7ea: a5 01 movw r20, r10
|
|
7ec: 94 01 movw r18, r8
|
|
7ee: 0e 94 67 07 call 0xece ; 0xece <__udivmodsi4>
|
|
7f2: e6 2f mov r30, r22
|
|
n /= base;
|
|
7f4: b9 01 movw r22, r18
|
|
7f6: ca 01 movw r24, r20
|
|
|
|
*--str = c < 10 ? c + '0' : c + 'A' - 10;
|
|
7f8: 01 50 subi r16, 0x01 ; 1
|
|
7fa: 11 09 sbc r17, r1
|
|
7fc: ea 30 cpi r30, 0x0A ; 10
|
|
7fe: 14 f4 brge .+4 ; 0x804 <Print::printNumber(unsigned long, unsigned char) [clone .constprop.7]+0x50>
|
|
800: e0 5d subi r30, 0xD0 ; 208
|
|
802: 01 c0 rjmp .+2 ; 0x806 <Print::printNumber(unsigned long, unsigned char) [clone .constprop.7]+0x52>
|
|
804: e9 5c subi r30, 0xC9 ; 201
|
|
806: d8 01 movw r26, r16
|
|
808: ec 93 st X, r30
|
|
*str = '\0';
|
|
|
|
// prevent crash if called with base == 1
|
|
if (base < 2) base = 10;
|
|
|
|
do {
|
|
80a: 23 2b or r18, r19
|
|
80c: 24 2b or r18, r20
|
|
80e: 25 2b or r18, r21
|
|
810: 61 f7 brne .-40 ; 0x7ea <Print::printNumber(unsigned long, unsigned char) [clone .constprop.7]+0x36>
|
|
n /= base;
|
|
|
|
*--str = c < 10 ? c + '0' : c + 'A' - 10;
|
|
} while(n);
|
|
|
|
return write(str);
|
|
812: c8 01 movw r24, r16
|
|
814: 0e 94 c8 03 call 0x790 ; 0x790 <Print::write(char const*) [clone .constprop.10]>
|
|
}
|
|
818: a1 96 adiw r28, 0x21 ; 33
|
|
81a: 0f b6 in r0, 0x3f ; 63
|
|
81c: f8 94 cli
|
|
81e: de bf out 0x3e, r29 ; 62
|
|
820: 0f be out 0x3f, r0 ; 63
|
|
822: cd bf out 0x3d, r28 ; 61
|
|
824: df 91 pop r29
|
|
826: cf 91 pop r28
|
|
828: 1f 91 pop r17
|
|
82a: 0f 91 pop r16
|
|
82c: bf 90 pop r11
|
|
82e: af 90 pop r10
|
|
830: 9f 90 pop r9
|
|
832: 8f 90 pop r8
|
|
834: 08 95 ret
|
|
|
|
00000836 <__cxa_pure_virtual>:
|
|
extern "C" void __cxa_deleted_virtual(void) __attribute__ ((__noreturn__));
|
|
|
|
void __cxa_pure_virtual(void) {
|
|
// We might want to write some diagnostics to uart in this case
|
|
//std::terminate();
|
|
abort();
|
|
836: 0e 94 a3 07 call 0xf46 ; 0xf46 <abort>
|
|
|
|
0000083a <__vector_19>:
|
|
#elif defined(USART_UDRE_vect)
|
|
ISR(USART_UDRE_vect)
|
|
#else
|
|
#error "Don't know what the Data Register Empty vector is called for Serial"
|
|
#endif
|
|
{
|
|
83a: 1f 92 push r1
|
|
83c: 0f 92 push r0
|
|
83e: 0f b6 in r0, 0x3f ; 63
|
|
840: 0f 92 push r0
|
|
842: 11 24 eor r1, r1
|
|
844: 2f 93 push r18
|
|
846: 3f 93 push r19
|
|
848: 4f 93 push r20
|
|
84a: 5f 93 push r21
|
|
84c: 6f 93 push r22
|
|
84e: 7f 93 push r23
|
|
850: 8f 93 push r24
|
|
852: 9f 93 push r25
|
|
854: af 93 push r26
|
|
856: bf 93 push r27
|
|
858: ef 93 push r30
|
|
85a: ff 93 push r31
|
|
Serial._tx_udr_empty_irq();
|
|
85c: 87 e4 ldi r24, 0x47 ; 71
|
|
85e: 91 e0 ldi r25, 0x01 ; 1
|
|
860: 0e 94 42 01 call 0x284 ; 0x284 <HardwareSerial::_tx_udr_empty_irq()>
|
|
}
|
|
864: ff 91 pop r31
|
|
866: ef 91 pop r30
|
|
868: bf 91 pop r27
|
|
86a: af 91 pop r26
|
|
86c: 9f 91 pop r25
|
|
86e: 8f 91 pop r24
|
|
870: 7f 91 pop r23
|
|
872: 6f 91 pop r22
|
|
874: 5f 91 pop r21
|
|
876: 4f 91 pop r20
|
|
878: 3f 91 pop r19
|
|
87a: 2f 91 pop r18
|
|
87c: 0f 90 pop r0
|
|
87e: 0f be out 0x3f, r0 ; 63
|
|
880: 0f 90 pop r0
|
|
882: 1f 90 pop r1
|
|
884: 18 95 reti
|
|
|
|
00000886 <__vector_18>:
|
|
#elif defined(USART_RXC_vect)
|
|
ISR(USART_RXC_vect) // ATmega8
|
|
#else
|
|
#error "Don't know what the Data Received vector is called for Serial"
|
|
#endif
|
|
{
|
|
886: 1f 92 push r1
|
|
888: 0f 92 push r0
|
|
88a: 0f b6 in r0, 0x3f ; 63
|
|
88c: 0f 92 push r0
|
|
88e: 11 24 eor r1, r1
|
|
890: 2f 93 push r18
|
|
892: 8f 93 push r24
|
|
894: 9f 93 push r25
|
|
896: ef 93 push r30
|
|
898: ff 93 push r31
|
|
|
|
// Actual interrupt handlers //////////////////////////////////////////////////////////////
|
|
|
|
void HardwareSerial::_rx_complete_irq(void)
|
|
{
|
|
if (bit_is_clear(*_ucsra, UPE0)) {
|
|
89a: e0 91 57 01 lds r30, 0x0157 ; 0x800157 <Serial+0x10>
|
|
89e: f0 91 58 01 lds r31, 0x0158 ; 0x800158 <Serial+0x11>
|
|
8a2: 80 81 ld r24, Z
|
|
8a4: e0 91 5d 01 lds r30, 0x015D ; 0x80015d <Serial+0x16>
|
|
8a8: f0 91 5e 01 lds r31, 0x015E ; 0x80015e <Serial+0x17>
|
|
8ac: 82 fd sbrc r24, 2
|
|
8ae: 12 c0 rjmp .+36 ; 0x8d4 <__vector_18+0x4e>
|
|
// No Parity error, read byte and store it in the buffer if there is
|
|
// room
|
|
unsigned char c = *_udr;
|
|
8b0: 90 81 ld r25, Z
|
|
rx_buffer_index_t i = (unsigned int)(_rx_buffer_head + 1) % SERIAL_RX_BUFFER_SIZE;
|
|
8b2: 80 91 60 01 lds r24, 0x0160 ; 0x800160 <Serial+0x19>
|
|
8b6: 8f 5f subi r24, 0xFF ; 255
|
|
8b8: 8f 73 andi r24, 0x3F ; 63
|
|
|
|
// if we should be storing the received character into the location
|
|
// just before the tail (meaning that the head would advance to the
|
|
// current location of the tail), we're about to overflow the buffer
|
|
// and so we don't write the character or advance the head.
|
|
if (i != _rx_buffer_tail) {
|
|
8ba: 20 91 61 01 lds r18, 0x0161 ; 0x800161 <Serial+0x1a>
|
|
8be: 82 17 cp r24, r18
|
|
8c0: 51 f0 breq .+20 ; 0x8d6 <__vector_18+0x50>
|
|
_rx_buffer[_rx_buffer_head] = c;
|
|
8c2: e0 91 60 01 lds r30, 0x0160 ; 0x800160 <Serial+0x19>
|
|
8c6: f0 e0 ldi r31, 0x00 ; 0
|
|
8c8: e9 5b subi r30, 0xB9 ; 185
|
|
8ca: fe 4f sbci r31, 0xFE ; 254
|
|
8cc: 95 8f std Z+29, r25 ; 0x1d
|
|
_rx_buffer_head = i;
|
|
8ce: 80 93 60 01 sts 0x0160, r24 ; 0x800160 <Serial+0x19>
|
|
8d2: 01 c0 rjmp .+2 ; 0x8d6 <__vector_18+0x50>
|
|
}
|
|
} else {
|
|
// Parity error, read byte but discard it
|
|
*_udr;
|
|
8d4: 80 81 ld r24, Z
|
|
Serial._rx_complete_irq();
|
|
}
|
|
8d6: ff 91 pop r31
|
|
8d8: ef 91 pop r30
|
|
8da: 9f 91 pop r25
|
|
8dc: 8f 91 pop r24
|
|
8de: 2f 91 pop r18
|
|
8e0: 0f 90 pop r0
|
|
8e2: 0f be out 0x3f, r0 ; 63
|
|
8e4: 0f 90 pop r0
|
|
8e6: 1f 90 pop r1
|
|
8e8: 18 95 reti
|
|
|
|
000008ea <__vector_16>:
|
|
#if defined(__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
|
|
ISR(TIM0_OVF_vect)
|
|
#else
|
|
ISR(TIMER0_OVF_vect)
|
|
#endif
|
|
{
|
|
8ea: 1f 92 push r1
|
|
8ec: 0f 92 push r0
|
|
8ee: 0f b6 in r0, 0x3f ; 63
|
|
8f0: 0f 92 push r0
|
|
8f2: 11 24 eor r1, r1
|
|
8f4: 2f 93 push r18
|
|
8f6: 3f 93 push r19
|
|
8f8: 8f 93 push r24
|
|
8fa: 9f 93 push r25
|
|
8fc: af 93 push r26
|
|
8fe: bf 93 push r27
|
|
// copy these to local variables so they can be stored in registers
|
|
// (volatile variables must be read from memory on every access)
|
|
unsigned long m = timer0_millis;
|
|
900: 80 91 19 01 lds r24, 0x0119 ; 0x800119 <timer0_millis>
|
|
904: 90 91 1a 01 lds r25, 0x011A ; 0x80011a <timer0_millis+0x1>
|
|
908: a0 91 1b 01 lds r26, 0x011B ; 0x80011b <timer0_millis+0x2>
|
|
90c: b0 91 1c 01 lds r27, 0x011C ; 0x80011c <timer0_millis+0x3>
|
|
unsigned char f = timer0_fract;
|
|
910: 30 91 18 01 lds r19, 0x0118 ; 0x800118 <timer0_fract>
|
|
|
|
m += MILLIS_INC;
|
|
f += FRACT_INC;
|
|
914: 23 e0 ldi r18, 0x03 ; 3
|
|
916: 23 0f add r18, r19
|
|
if (f >= FRACT_MAX) {
|
|
918: 2d 37 cpi r18, 0x7D ; 125
|
|
91a: 20 f4 brcc .+8 ; 0x924 <__stack+0x25>
|
|
// copy these to local variables so they can be stored in registers
|
|
// (volatile variables must be read from memory on every access)
|
|
unsigned long m = timer0_millis;
|
|
unsigned char f = timer0_fract;
|
|
|
|
m += MILLIS_INC;
|
|
91c: 01 96 adiw r24, 0x01 ; 1
|
|
91e: a1 1d adc r26, r1
|
|
920: b1 1d adc r27, r1
|
|
922: 05 c0 rjmp .+10 ; 0x92e <__stack+0x2f>
|
|
f += FRACT_INC;
|
|
if (f >= FRACT_MAX) {
|
|
f -= FRACT_MAX;
|
|
924: 26 e8 ldi r18, 0x86 ; 134
|
|
926: 23 0f add r18, r19
|
|
m += 1;
|
|
928: 02 96 adiw r24, 0x02 ; 2
|
|
92a: a1 1d adc r26, r1
|
|
92c: b1 1d adc r27, r1
|
|
}
|
|
|
|
timer0_fract = f;
|
|
92e: 20 93 18 01 sts 0x0118, r18 ; 0x800118 <timer0_fract>
|
|
timer0_millis = m;
|
|
932: 80 93 19 01 sts 0x0119, r24 ; 0x800119 <timer0_millis>
|
|
936: 90 93 1a 01 sts 0x011A, r25 ; 0x80011a <timer0_millis+0x1>
|
|
93a: a0 93 1b 01 sts 0x011B, r26 ; 0x80011b <timer0_millis+0x2>
|
|
93e: b0 93 1c 01 sts 0x011C, r27 ; 0x80011c <timer0_millis+0x3>
|
|
timer0_overflow_count++;
|
|
942: 80 91 1d 01 lds r24, 0x011D ; 0x80011d <timer0_overflow_count>
|
|
946: 90 91 1e 01 lds r25, 0x011E ; 0x80011e <timer0_overflow_count+0x1>
|
|
94a: a0 91 1f 01 lds r26, 0x011F ; 0x80011f <timer0_overflow_count+0x2>
|
|
94e: b0 91 20 01 lds r27, 0x0120 ; 0x800120 <timer0_overflow_count+0x3>
|
|
952: 01 96 adiw r24, 0x01 ; 1
|
|
954: a1 1d adc r26, r1
|
|
956: b1 1d adc r27, r1
|
|
958: 80 93 1d 01 sts 0x011D, r24 ; 0x80011d <timer0_overflow_count>
|
|
95c: 90 93 1e 01 sts 0x011E, r25 ; 0x80011e <timer0_overflow_count+0x1>
|
|
960: a0 93 1f 01 sts 0x011F, r26 ; 0x80011f <timer0_overflow_count+0x2>
|
|
964: b0 93 20 01 sts 0x0120, r27 ; 0x800120 <timer0_overflow_count+0x3>
|
|
}
|
|
968: bf 91 pop r27
|
|
96a: af 91 pop r26
|
|
96c: 9f 91 pop r25
|
|
96e: 8f 91 pop r24
|
|
970: 3f 91 pop r19
|
|
972: 2f 91 pop r18
|
|
974: 0f 90 pop r0
|
|
976: 0f be out 0x3f, r0 ; 63
|
|
978: 0f 90 pop r0
|
|
97a: 1f 90 pop r1
|
|
97c: 18 95 reti
|
|
|
|
0000097e <global constructors keyed to 65535_0_shiftin_try6_wLED.ino.cpp.o.1832>:
|
|
97e: cf 93 push r28
|
|
980: df 93 push r29
|
|
size_t printNumber(unsigned long, uint8_t);
|
|
size_t printFloat(double, uint8_t);
|
|
protected:
|
|
void setWriteError(int err = 1) { write_error = err; }
|
|
public:
|
|
Print() : write_error(0) {}
|
|
982: 10 92 4a 01 sts 0x014A, r1 ; 0x80014a <Serial+0x3>
|
|
986: 10 92 49 01 sts 0x0149, r1 ; 0x800149 <Serial+0x2>
|
|
public:
|
|
virtual int available() = 0;
|
|
virtual int read() = 0;
|
|
virtual int peek() = 0;
|
|
|
|
Stream() {_timeout=1000;}
|
|
98a: 88 ee ldi r24, 0xE8 ; 232
|
|
98c: 93 e0 ldi r25, 0x03 ; 3
|
|
98e: a0 e0 ldi r26, 0x00 ; 0
|
|
990: b0 e0 ldi r27, 0x00 ; 0
|
|
992: 80 93 4b 01 sts 0x014B, r24 ; 0x80014b <Serial+0x4>
|
|
996: 90 93 4c 01 sts 0x014C, r25 ; 0x80014c <Serial+0x5>
|
|
99a: a0 93 4d 01 sts 0x014D, r26 ; 0x80014d <Serial+0x6>
|
|
99e: b0 93 4e 01 sts 0x014E, r27 ; 0x80014e <Serial+0x7>
|
|
volatile uint8_t *ucsrc, volatile uint8_t *udr) :
|
|
_ubrrh(ubrrh), _ubrrl(ubrrl),
|
|
_ucsra(ucsra), _ucsrb(ucsrb), _ucsrc(ucsrc),
|
|
_udr(udr),
|
|
_rx_buffer_head(0), _rx_buffer_tail(0),
|
|
_tx_buffer_head(0), _tx_buffer_tail(0)
|
|
9a2: 84 e0 ldi r24, 0x04 ; 4
|
|
9a4: 91 e0 ldi r25, 0x01 ; 1
|
|
9a6: 90 93 48 01 sts 0x0148, r25 ; 0x800148 <Serial+0x1>
|
|
9aa: 80 93 47 01 sts 0x0147, r24 ; 0x800147 <Serial>
|
|
9ae: 85 ec ldi r24, 0xC5 ; 197
|
|
9b0: 90 e0 ldi r25, 0x00 ; 0
|
|
9b2: 90 93 54 01 sts 0x0154, r25 ; 0x800154 <Serial+0xd>
|
|
9b6: 80 93 53 01 sts 0x0153, r24 ; 0x800153 <Serial+0xc>
|
|
9ba: 84 ec ldi r24, 0xC4 ; 196
|
|
9bc: 90 e0 ldi r25, 0x00 ; 0
|
|
9be: 90 93 56 01 sts 0x0156, r25 ; 0x800156 <Serial+0xf>
|
|
9c2: 80 93 55 01 sts 0x0155, r24 ; 0x800155 <Serial+0xe>
|
|
9c6: 80 ec ldi r24, 0xC0 ; 192
|
|
9c8: 90 e0 ldi r25, 0x00 ; 0
|
|
9ca: 90 93 58 01 sts 0x0158, r25 ; 0x800158 <Serial+0x11>
|
|
9ce: 80 93 57 01 sts 0x0157, r24 ; 0x800157 <Serial+0x10>
|
|
9d2: 81 ec ldi r24, 0xC1 ; 193
|
|
9d4: 90 e0 ldi r25, 0x00 ; 0
|
|
9d6: 90 93 5a 01 sts 0x015A, r25 ; 0x80015a <Serial+0x13>
|
|
9da: 80 93 59 01 sts 0x0159, r24 ; 0x800159 <Serial+0x12>
|
|
9de: 82 ec ldi r24, 0xC2 ; 194
|
|
9e0: 90 e0 ldi r25, 0x00 ; 0
|
|
9e2: 90 93 5c 01 sts 0x015C, r25 ; 0x80015c <Serial+0x15>
|
|
9e6: 80 93 5b 01 sts 0x015B, r24 ; 0x80015b <Serial+0x14>
|
|
9ea: 86 ec ldi r24, 0xC6 ; 198
|
|
9ec: 90 e0 ldi r25, 0x00 ; 0
|
|
9ee: 90 93 5e 01 sts 0x015E, r25 ; 0x80015e <Serial+0x17>
|
|
9f2: 80 93 5d 01 sts 0x015D, r24 ; 0x80015d <Serial+0x16>
|
|
9f6: 10 92 60 01 sts 0x0160, r1 ; 0x800160 <Serial+0x19>
|
|
9fa: 10 92 61 01 sts 0x0161, r1 ; 0x800161 <Serial+0x1a>
|
|
9fe: 10 92 62 01 sts 0x0162, r1 ; 0x800162 <Serial+0x1b>
|
|
a02: 10 92 63 01 sts 0x0163, r1 ; 0x800163 <Serial+0x1c>
|
|
#define OP_SCANLIMIT 11
|
|
#define OP_SHUTDOWN 12
|
|
#define OP_DISPLAYTEST 15
|
|
|
|
LedControl::LedControl(int dataPin, int clkPin, int csPin, int numDevices) {
|
|
SPI_MOSI=dataPin;
|
|
a06: cc e0 ldi r28, 0x0C ; 12
|
|
a08: d0 e0 ldi r29, 0x00 ; 0
|
|
a0a: d0 93 35 02 sts 0x0235, r29 ; 0x800235 <lc+0x51>
|
|
a0e: c0 93 34 02 sts 0x0234, r28 ; 0x800234 <lc+0x50>
|
|
SPI_CLK=clkPin;
|
|
a12: 8b e0 ldi r24, 0x0B ; 11
|
|
a14: 90 e0 ldi r25, 0x00 ; 0
|
|
a16: 90 93 37 02 sts 0x0237, r25 ; 0x800237 <lc+0x53>
|
|
a1a: 80 93 36 02 sts 0x0236, r24 ; 0x800236 <lc+0x52>
|
|
SPI_CS=csPin;
|
|
a1e: 8a e0 ldi r24, 0x0A ; 10
|
|
a20: 90 e0 ldi r25, 0x00 ; 0
|
|
a22: 90 93 39 02 sts 0x0239, r25 ; 0x800239 <lc+0x55>
|
|
a26: 80 93 38 02 sts 0x0238, r24 ; 0x800238 <lc+0x54>
|
|
if(numDevices<=0 || numDevices>8 )
|
|
numDevices=8;
|
|
maxDevices=numDevices;
|
|
a2a: 81 e0 ldi r24, 0x01 ; 1
|
|
a2c: 90 e0 ldi r25, 0x00 ; 0
|
|
a2e: 90 93 3b 02 sts 0x023B, r25 ; 0x80023b <lc+0x57>
|
|
a32: 80 93 3a 02 sts 0x023A, r24 ; 0x80023a <lc+0x56>
|
|
pinMode(SPI_MOSI,OUTPUT);
|
|
a36: 61 e0 ldi r22, 0x01 ; 1
|
|
a38: 8c e0 ldi r24, 0x0C ; 12
|
|
a3a: 0e 94 58 02 call 0x4b0 ; 0x4b0 <pinMode>
|
|
pinMode(SPI_CLK,OUTPUT);
|
|
a3e: 61 e0 ldi r22, 0x01 ; 1
|
|
a40: 80 91 36 02 lds r24, 0x0236 ; 0x800236 <lc+0x52>
|
|
a44: 0e 94 58 02 call 0x4b0 ; 0x4b0 <pinMode>
|
|
pinMode(SPI_CS,OUTPUT);
|
|
a48: 61 e0 ldi r22, 0x01 ; 1
|
|
a4a: 80 91 38 02 lds r24, 0x0238 ; 0x800238 <lc+0x54>
|
|
a4e: 0e 94 58 02 call 0x4b0 ; 0x4b0 <pinMode>
|
|
digitalWrite(SPI_CS,HIGH);
|
|
a52: 61 e0 ldi r22, 0x01 ; 1
|
|
a54: 80 91 38 02 lds r24, 0x0238 ; 0x800238 <lc+0x54>
|
|
a58: 0e 94 28 02 call 0x450 ; 0x450 <digitalWrite>
|
|
SPI_MOSI=dataPin;
|
|
a5c: d0 93 35 02 sts 0x0235, r29 ; 0x800235 <lc+0x51>
|
|
a60: c0 93 34 02 sts 0x0234, r28 ; 0x800234 <lc+0x50>
|
|
a64: e4 ef ldi r30, 0xF4 ; 244
|
|
a66: f1 e0 ldi r31, 0x01 ; 1
|
|
for(int i=0;i<64;i++)
|
|
status[i]=0x00;
|
|
a68: 11 92 st Z+, r1
|
|
pinMode(SPI_MOSI,OUTPUT);
|
|
pinMode(SPI_CLK,OUTPUT);
|
|
pinMode(SPI_CS,OUTPUT);
|
|
digitalWrite(SPI_CS,HIGH);
|
|
SPI_MOSI=dataPin;
|
|
for(int i=0;i<64;i++)
|
|
a6a: 82 e0 ldi r24, 0x02 ; 2
|
|
a6c: e4 33 cpi r30, 0x34 ; 52
|
|
a6e: f8 07 cpc r31, r24
|
|
a70: d9 f7 brne .-10 ; 0xa68 <global constructors keyed to 65535_0_shiftin_try6_wLED.ino.cpp.o.1832+0xea>
|
|
a72: c0 e0 ldi r28, 0x00 ; 0
|
|
a74: d0 e0 ldi r29, 0x00 ; 0
|
|
status[i]=0x00;
|
|
for(int i=0;i<maxDevices;i++) {
|
|
a76: 80 91 3a 02 lds r24, 0x023A ; 0x80023a <lc+0x56>
|
|
a7a: 90 91 3b 02 lds r25, 0x023B ; 0x80023b <lc+0x57>
|
|
a7e: c8 17 cp r28, r24
|
|
a80: d9 07 cpc r29, r25
|
|
a82: ac f5 brge .+106 ; 0xaee <global constructors keyed to 65535_0_shiftin_try6_wLED.ino.cpp.o.1832+0x170>
|
|
spiTransfer(i,OP_DISPLAYTEST,0);
|
|
a84: 20 e0 ldi r18, 0x00 ; 0
|
|
a86: 4f e0 ldi r20, 0x0F ; 15
|
|
a88: be 01 movw r22, r28
|
|
a8a: 84 ee ldi r24, 0xE4 ; 228
|
|
a8c: 91 e0 ldi r25, 0x01 ; 1
|
|
a8e: 0e 94 ed 02 call 0x5da ; 0x5da <LedControl::spiTransfer(int, unsigned char, unsigned char)>
|
|
else
|
|
spiTransfer(addr, OP_SHUTDOWN,1);
|
|
}
|
|
|
|
void LedControl::setScanLimit(int addr, int limit) {
|
|
if(addr<0 || addr>=maxDevices)
|
|
a92: d7 fd sbrc r29, 7
|
|
a94: 0e c0 rjmp .+28 ; 0xab2 <global constructors keyed to 65535_0_shiftin_try6_wLED.ino.cpp.o.1832+0x134>
|
|
a96: 80 91 3a 02 lds r24, 0x023A ; 0x80023a <lc+0x56>
|
|
a9a: 90 91 3b 02 lds r25, 0x023B ; 0x80023b <lc+0x57>
|
|
a9e: c8 17 cp r28, r24
|
|
aa0: d9 07 cpc r29, r25
|
|
aa2: 3c f4 brge .+14 ; 0xab2 <global constructors keyed to 65535_0_shiftin_try6_wLED.ino.cpp.o.1832+0x134>
|
|
return;
|
|
if(limit>=0 && limit<8)
|
|
spiTransfer(addr, OP_SCANLIMIT,limit);
|
|
aa4: 27 e0 ldi r18, 0x07 ; 7
|
|
aa6: 4b e0 ldi r20, 0x0B ; 11
|
|
aa8: be 01 movw r22, r28
|
|
aaa: 84 ee ldi r24, 0xE4 ; 228
|
|
aac: 91 e0 ldi r25, 0x01 ; 1
|
|
aae: 0e 94 ed 02 call 0x5da ; 0x5da <LedControl::spiTransfer(int, unsigned char, unsigned char)>
|
|
for(int i=0;i<maxDevices;i++) {
|
|
spiTransfer(i,OP_DISPLAYTEST,0);
|
|
//scanlimit is set to max on startup
|
|
setScanLimit(i,7);
|
|
//decode is done in source
|
|
spiTransfer(i,OP_DECODEMODE,0);
|
|
ab2: 20 e0 ldi r18, 0x00 ; 0
|
|
ab4: 49 e0 ldi r20, 0x09 ; 9
|
|
ab6: be 01 movw r22, r28
|
|
ab8: 84 ee ldi r24, 0xE4 ; 228
|
|
aba: 91 e0 ldi r25, 0x01 ; 1
|
|
abc: 0e 94 ed 02 call 0x5da ; 0x5da <LedControl::spiTransfer(int, unsigned char, unsigned char)>
|
|
clearDisplay(i);
|
|
ac0: be 01 movw r22, r28
|
|
ac2: 84 ee ldi r24, 0xE4 ; 228
|
|
ac4: 91 e0 ldi r25, 0x01 ; 1
|
|
ac6: 0e 94 92 03 call 0x724 ; 0x724 <LedControl::clearDisplay(int)>
|
|
int LedControl::getDeviceCount() {
|
|
return maxDevices;
|
|
}
|
|
|
|
void LedControl::shutdown(int addr, bool b) {
|
|
if(addr<0 || addr>=maxDevices)
|
|
aca: d7 fd sbrc r29, 7
|
|
acc: 0e c0 rjmp .+28 ; 0xaea <global constructors keyed to 65535_0_shiftin_try6_wLED.ino.cpp.o.1832+0x16c>
|
|
ace: 80 91 3a 02 lds r24, 0x023A ; 0x80023a <lc+0x56>
|
|
ad2: 90 91 3b 02 lds r25, 0x023B ; 0x80023b <lc+0x57>
|
|
ad6: c8 17 cp r28, r24
|
|
ad8: d9 07 cpc r29, r25
|
|
ada: 3c f4 brge .+14 ; 0xaea <global constructors keyed to 65535_0_shiftin_try6_wLED.ino.cpp.o.1832+0x16c>
|
|
return;
|
|
if(b)
|
|
spiTransfer(addr, OP_SHUTDOWN,0);
|
|
adc: 20 e0 ldi r18, 0x00 ; 0
|
|
ade: 4c e0 ldi r20, 0x0C ; 12
|
|
ae0: be 01 movw r22, r28
|
|
ae2: 84 ee ldi r24, 0xE4 ; 228
|
|
ae4: 91 e0 ldi r25, 0x01 ; 1
|
|
ae6: 0e 94 ed 02 call 0x5da ; 0x5da <LedControl::spiTransfer(int, unsigned char, unsigned char)>
|
|
pinMode(SPI_CS,OUTPUT);
|
|
digitalWrite(SPI_CS,HIGH);
|
|
SPI_MOSI=dataPin;
|
|
for(int i=0;i<64;i++)
|
|
status[i]=0x00;
|
|
for(int i=0;i<maxDevices;i++) {
|
|
aea: 21 96 adiw r28, 0x01 ; 1
|
|
aec: c4 cf rjmp .-120 ; 0xa76 <global constructors keyed to 65535_0_shiftin_try6_wLED.ino.cpp.o.1832+0xf8>
|
|
aee: df 91 pop r29
|
|
af0: cf 91 pop r28
|
|
af2: 08 95 ret
|
|
|
|
00000af4 <main>:
|
|
|
|
void init()
|
|
{
|
|
// this needs to be called before setup() or some functions won't
|
|
// work there
|
|
sei();
|
|
af4: 78 94 sei
|
|
|
|
// on the ATmega168, timer 0 is also used for fast hardware pwm
|
|
// (using phase-correct PWM would mean that timer 0 overflowed half as often
|
|
// resulting in different millis() behavior on the ATmega8 and ATmega168)
|
|
#if defined(TCCR0A) && defined(WGM01)
|
|
sbi(TCCR0A, WGM01);
|
|
af6: 84 b5 in r24, 0x24 ; 36
|
|
af8: 82 60 ori r24, 0x02 ; 2
|
|
afa: 84 bd out 0x24, r24 ; 36
|
|
sbi(TCCR0A, WGM00);
|
|
afc: 84 b5 in r24, 0x24 ; 36
|
|
afe: 81 60 ori r24, 0x01 ; 1
|
|
b00: 84 bd out 0x24, r24 ; 36
|
|
// this combination is for the standard atmega8
|
|
sbi(TCCR0, CS01);
|
|
sbi(TCCR0, CS00);
|
|
#elif defined(TCCR0B) && defined(CS01) && defined(CS00)
|
|
// this combination is for the standard 168/328/1280/2560
|
|
sbi(TCCR0B, CS01);
|
|
b02: 85 b5 in r24, 0x25 ; 37
|
|
b04: 82 60 ori r24, 0x02 ; 2
|
|
b06: 85 bd out 0x25, r24 ; 37
|
|
sbi(TCCR0B, CS00);
|
|
b08: 85 b5 in r24, 0x25 ; 37
|
|
b0a: 81 60 ori r24, 0x01 ; 1
|
|
b0c: 85 bd out 0x25, r24 ; 37
|
|
|
|
// enable timer 0 overflow interrupt
|
|
#if defined(TIMSK) && defined(TOIE0)
|
|
sbi(TIMSK, TOIE0);
|
|
#elif defined(TIMSK0) && defined(TOIE0)
|
|
sbi(TIMSK0, TOIE0);
|
|
b0e: 80 91 6e 00 lds r24, 0x006E ; 0x80006e <__TEXT_REGION_LENGTH__+0x7e006e>
|
|
b12: 81 60 ori r24, 0x01 ; 1
|
|
b14: 80 93 6e 00 sts 0x006E, r24 ; 0x80006e <__TEXT_REGION_LENGTH__+0x7e006e>
|
|
// this is better for motors as it ensures an even waveform
|
|
// note, however, that fast pwm mode can achieve a frequency of up
|
|
// 8 MHz (with a 16 MHz clock) at 50% duty cycle
|
|
|
|
#if defined(TCCR1B) && defined(CS11) && defined(CS10)
|
|
TCCR1B = 0;
|
|
b18: 10 92 81 00 sts 0x0081, r1 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081>
|
|
|
|
// set timer 1 prescale factor to 64
|
|
sbi(TCCR1B, CS11);
|
|
b1c: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081>
|
|
b20: 82 60 ori r24, 0x02 ; 2
|
|
b22: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081>
|
|
#if F_CPU >= 8000000L
|
|
sbi(TCCR1B, CS10);
|
|
b26: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081>
|
|
b2a: 81 60 ori r24, 0x01 ; 1
|
|
b2c: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081>
|
|
sbi(TCCR1, CS10);
|
|
#endif
|
|
#endif
|
|
// put timer 1 in 8-bit phase correct pwm mode
|
|
#if defined(TCCR1A) && defined(WGM10)
|
|
sbi(TCCR1A, WGM10);
|
|
b30: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080>
|
|
b34: 81 60 ori r24, 0x01 ; 1
|
|
b36: 80 93 80 00 sts 0x0080, r24 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080>
|
|
|
|
// set timer 2 prescale factor to 64
|
|
#if defined(TCCR2) && defined(CS22)
|
|
sbi(TCCR2, CS22);
|
|
#elif defined(TCCR2B) && defined(CS22)
|
|
sbi(TCCR2B, CS22);
|
|
b3a: 80 91 b1 00 lds r24, 0x00B1 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1>
|
|
b3e: 84 60 ori r24, 0x04 ; 4
|
|
b40: 80 93 b1 00 sts 0x00B1, r24 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1>
|
|
|
|
// configure timer 2 for phase correct pwm (8-bit)
|
|
#if defined(TCCR2) && defined(WGM20)
|
|
sbi(TCCR2, WGM20);
|
|
#elif defined(TCCR2A) && defined(WGM20)
|
|
sbi(TCCR2A, WGM20);
|
|
b44: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0>
|
|
b48: 81 60 ori r24, 0x01 ; 1
|
|
b4a: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0>
|
|
#endif
|
|
|
|
#if defined(ADCSRA)
|
|
// set a2d prescaler so we are inside the desired 50-200 KHz range.
|
|
#if F_CPU >= 16000000 // 16 MHz / 128 = 125 KHz
|
|
sbi(ADCSRA, ADPS2);
|
|
b4e: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
|
|
b52: 84 60 ori r24, 0x04 ; 4
|
|
b54: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
|
|
sbi(ADCSRA, ADPS1);
|
|
b58: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
|
|
b5c: 82 60 ori r24, 0x02 ; 2
|
|
b5e: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
|
|
sbi(ADCSRA, ADPS0);
|
|
b62: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
|
|
b66: 81 60 ori r24, 0x01 ; 1
|
|
b68: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
|
|
cbi(ADCSRA, ADPS2);
|
|
cbi(ADCSRA, ADPS1);
|
|
sbi(ADCSRA, ADPS0);
|
|
#endif
|
|
// enable a2d conversions
|
|
sbi(ADCSRA, ADEN);
|
|
b6c: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
|
|
b70: 80 68 ori r24, 0x80 ; 128
|
|
b72: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
|
|
// here so they can be used as normal digital i/o; they will be
|
|
// reconnected in Serial.begin()
|
|
#if defined(UCSRB)
|
|
UCSRB = 0;
|
|
#elif defined(UCSR0B)
|
|
UCSR0B = 0;
|
|
b76: 10 92 c1 00 sts 0x00C1, r1 ; 0x8000c1 <__TEXT_REGION_LENGTH__+0x7e00c1>
|
|
|
|
void setup() {
|
|
// put your setup code here, to run once:
|
|
|
|
|
|
pinMode(hzclk, INPUT);
|
|
b7a: 60 e0 ldi r22, 0x00 ; 0
|
|
b7c: 87 e0 ldi r24, 0x07 ; 7
|
|
b7e: 0e 94 58 02 call 0x4b0 ; 0x4b0 <pinMode>
|
|
pinMode(hzbinary, INPUT);
|
|
b82: 60 e0 ldi r22, 0x00 ; 0
|
|
b84: 86 e0 ldi r24, 0x06 ; 6
|
|
b86: 0e 94 58 02 call 0x4b0 ; 0x4b0 <pinMode>
|
|
pinMode(sigLED, OUTPUT);
|
|
b8a: 61 e0 ldi r22, 0x01 ; 1
|
|
b8c: 8b e0 ldi r24, 0x0B ; 11
|
|
b8e: 0e 94 58 02 call 0x4b0 ; 0x4b0 <pinMode>
|
|
|
|
void HardwareSerial::begin(unsigned long baud, byte config)
|
|
{
|
|
// Try u2x mode first
|
|
uint16_t baud_setting = (F_CPU / 4 / baud - 1) / 2;
|
|
*_ucsra = 1 << U2X0;
|
|
b92: e0 91 57 01 lds r30, 0x0157 ; 0x800157 <Serial+0x10>
|
|
b96: f0 91 58 01 lds r31, 0x0158 ; 0x800158 <Serial+0x11>
|
|
b9a: 82 e0 ldi r24, 0x02 ; 2
|
|
b9c: 80 83 st Z, r24
|
|
*_ucsra = 0;
|
|
baud_setting = (F_CPU / 8 / baud - 1) / 2;
|
|
}
|
|
|
|
// assign the baud_setting, a.k.a. ubrr (USART Baud Rate Register)
|
|
*_ubrrh = baud_setting >> 8;
|
|
b9e: e0 91 53 01 lds r30, 0x0153 ; 0x800153 <Serial+0xc>
|
|
ba2: f0 91 54 01 lds r31, 0x0154 ; 0x800154 <Serial+0xd>
|
|
ba6: 10 82 st Z, r1
|
|
*_ubrrl = baud_setting;
|
|
ba8: e0 91 55 01 lds r30, 0x0155 ; 0x800155 <Serial+0xe>
|
|
bac: f0 91 56 01 lds r31, 0x0156 ; 0x800156 <Serial+0xf>
|
|
bb0: 80 e1 ldi r24, 0x10 ; 16
|
|
bb2: 80 83 st Z, r24
|
|
|
|
_written = false;
|
|
bb4: 10 92 5f 01 sts 0x015F, r1 ; 0x80015f <Serial+0x18>
|
|
|
|
//set the data bits, parity, and stop bits
|
|
#if defined(__AVR_ATmega8__)
|
|
config |= 0x80; // select UCSRC register (shared with UBRRH)
|
|
#endif
|
|
*_ucsrc = config;
|
|
bb8: e0 91 5b 01 lds r30, 0x015B ; 0x80015b <Serial+0x14>
|
|
bbc: f0 91 5c 01 lds r31, 0x015C ; 0x80015c <Serial+0x15>
|
|
bc0: 86 e0 ldi r24, 0x06 ; 6
|
|
bc2: 80 83 st Z, r24
|
|
|
|
sbi(*_ucsrb, RXEN0);
|
|
bc4: e0 91 59 01 lds r30, 0x0159 ; 0x800159 <Serial+0x12>
|
|
bc8: f0 91 5a 01 lds r31, 0x015A ; 0x80015a <Serial+0x13>
|
|
bcc: 80 81 ld r24, Z
|
|
bce: 80 61 ori r24, 0x10 ; 16
|
|
bd0: 80 83 st Z, r24
|
|
sbi(*_ucsrb, TXEN0);
|
|
bd2: e0 91 59 01 lds r30, 0x0159 ; 0x800159 <Serial+0x12>
|
|
bd6: f0 91 5a 01 lds r31, 0x015A ; 0x80015a <Serial+0x13>
|
|
bda: 80 81 ld r24, Z
|
|
bdc: 88 60 ori r24, 0x08 ; 8
|
|
bde: 80 83 st Z, r24
|
|
sbi(*_ucsrb, RXCIE0);
|
|
be0: e0 91 59 01 lds r30, 0x0159 ; 0x800159 <Serial+0x12>
|
|
be4: f0 91 5a 01 lds r31, 0x015A ; 0x80015a <Serial+0x13>
|
|
be8: 80 81 ld r24, Z
|
|
bea: 80 68 ori r24, 0x80 ; 128
|
|
bec: 80 83 st Z, r24
|
|
cbi(*_ucsrb, UDRIE0);
|
|
bee: e0 91 59 01 lds r30, 0x0159 ; 0x800159 <Serial+0x12>
|
|
bf2: f0 91 5a 01 lds r31, 0x015A ; 0x80015a <Serial+0x13>
|
|
bf6: 80 81 ld r24, Z
|
|
bf8: 8f 7d andi r24, 0xDF ; 223
|
|
bfa: 80 83 st Z, r24
|
|
int LedControl::getDeviceCount() {
|
|
return maxDevices;
|
|
}
|
|
|
|
void LedControl::shutdown(int addr, bool b) {
|
|
if(addr<0 || addr>=maxDevices)
|
|
bfc: 80 91 3a 02 lds r24, 0x023A ; 0x80023a <lc+0x56>
|
|
c00: 90 91 3b 02 lds r25, 0x023B ; 0x80023b <lc+0x57>
|
|
c04: 18 16 cp r1, r24
|
|
c06: 19 06 cpc r1, r25
|
|
c08: 44 f4 brge .+16 ; 0xc1a <main+0x126>
|
|
return;
|
|
if(b)
|
|
spiTransfer(addr, OP_SHUTDOWN,0);
|
|
else
|
|
spiTransfer(addr, OP_SHUTDOWN,1);
|
|
c0a: 21 e0 ldi r18, 0x01 ; 1
|
|
c0c: 4c e0 ldi r20, 0x0C ; 12
|
|
c0e: 60 e0 ldi r22, 0x00 ; 0
|
|
c10: 70 e0 ldi r23, 0x00 ; 0
|
|
c12: 84 ee ldi r24, 0xE4 ; 228
|
|
c14: 91 e0 ldi r25, 0x01 ; 1
|
|
c16: 0e 94 ed 02 call 0x5da ; 0x5da <LedControl::spiTransfer(int, unsigned char, unsigned char)>
|
|
if(limit>=0 && limit<8)
|
|
spiTransfer(addr, OP_SCANLIMIT,limit);
|
|
}
|
|
|
|
void LedControl::setIntensity(int addr, int intensity) {
|
|
if(addr<0 || addr>=maxDevices)
|
|
c1a: 80 91 3a 02 lds r24, 0x023A ; 0x80023a <lc+0x56>
|
|
c1e: 90 91 3b 02 lds r25, 0x023B ; 0x80023b <lc+0x57>
|
|
c22: 18 16 cp r1, r24
|
|
c24: 19 06 cpc r1, r25
|
|
c26: 44 f4 brge .+16 ; 0xc38 <main+0x144>
|
|
return;
|
|
if(intensity>=0 && intensity<16)
|
|
spiTransfer(addr, OP_INTENSITY,intensity);
|
|
c28: 28 e0 ldi r18, 0x08 ; 8
|
|
c2a: 4a e0 ldi r20, 0x0A ; 10
|
|
c2c: 60 e0 ldi r22, 0x00 ; 0
|
|
c2e: 70 e0 ldi r23, 0x00 ; 0
|
|
c30: 84 ee ldi r24, 0xE4 ; 228
|
|
c32: 91 e0 ldi r25, 0x01 ; 1
|
|
c34: 0e 94 ed 02 call 0x5da ; 0x5da <LedControl::spiTransfer(int, unsigned char, unsigned char)>
|
|
*/
|
|
lc.shutdown(0,false);
|
|
/* Set the brightness to a medium values */
|
|
lc.setIntensity(0,8);
|
|
/* and clear the display */
|
|
lc.clearDisplay(0);
|
|
c38: 60 e0 ldi r22, 0x00 ; 0
|
|
c3a: 70 e0 ldi r23, 0x00 ; 0
|
|
c3c: 84 ee ldi r24, 0xE4 ; 228
|
|
c3e: 91 e0 ldi r25, 0x01 ; 1
|
|
c40: 0e 94 92 03 call 0x724 ; 0x724 <LedControl::clearDisplay(int)>
|
|
}
|
|
|
|
void ConvertArraytoBin (void){
|
|
for(x=4;x<21;x++){
|
|
if(hzbinval[x] == 1){
|
|
bitfieldA.mainstwo = bitfieldA.mainstwo | (0b0000000000000000000001 << (x - 3));
|
|
c44: ee 24 eor r14, r14
|
|
c46: e3 94 inc r14
|
|
c48: f1 2c mov r15, r1
|
|
if(v<0) {
|
|
negative=true;
|
|
v=v*-1;
|
|
}
|
|
ones=v%10;
|
|
v=v/10;
|
|
c4a: ca e0 ldi r28, 0x0A ; 10
|
|
c4c: d0 e0 ldi r29, 0x00 ; 0
|
|
//direct port reads
|
|
if(temp == 5047){
|
|
temp = 5998; //something, something, premature optimization...
|
|
}
|
|
if(temp == 5048){
|
|
temp = 6000; //LUTs
|
|
c4e: 30 e7 ldi r19, 0x70 ; 112
|
|
c50: c3 2e mov r12, r19
|
|
c52: 37 e1 ldi r19, 0x17 ; 23
|
|
c54: d3 2e mov r13, r19
|
|
//results in a clock that is right most of the time.
|
|
//but wrong every 20 or so counts
|
|
//todo: fix timing of duino by removing digital read for
|
|
//direct port reads
|
|
if(temp == 5047){
|
|
temp = 5998; //something, something, premature optimization...
|
|
c56: 4e e6 ldi r20, 0x6E ; 110
|
|
c58: 24 2e mov r2, r20
|
|
c5a: 47 e1 ldi r20, 0x17 ; 23
|
|
c5c: 34 2e mov r3, r20
|
|
|
|
|
|
#endif
|
|
|
|
// busy wait
|
|
__asm__ __volatile__ (
|
|
c5e: 0b e8 ldi r16, 0x8B ; 139
|
|
c60: 11 e0 ldi r17, 0x01 ; 1
|
|
}
|
|
|
|
void loop() {
|
|
|
|
|
|
if(digitalRead(hzbinary) == LOW){
|
|
c62: 86 e0 ldi r24, 0x06 ; 6
|
|
c64: 0e 94 ff 01 call 0x3fe ; 0x3fe <digitalRead>
|
|
c68: 89 2b or r24, r25
|
|
c6a: 09 f0 breq .+2 ; 0xc6e <main+0x17a>
|
|
c6c: 16 c1 rjmp .+556 ; 0xe9a <main+0x3a6>
|
|
//this handles one clk cycle each
|
|
//need to read 20 cycles
|
|
clkval = 0;
|
|
c6e: 10 92 46 01 sts 0x0146, r1 ; 0x800146 <clkval>
|
|
checkCLKandBIN();checkCLKandBIN();checkCLKandBIN();
|
|
c72: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
c76: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
c7a: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
checkCLKandBIN();checkCLKandBIN();checkCLKandBIN();
|
|
c7e: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
c82: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
c86: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
checkCLKandBIN();checkCLKandBIN();checkCLKandBIN();
|
|
c8a: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
c8e: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
c92: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
checkCLKandBIN();checkCLKandBIN();checkCLKandBIN();
|
|
c96: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
c9a: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
c9e: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
checkCLKandBIN();checkCLKandBIN();checkCLKandBIN();
|
|
ca2: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
ca6: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
caa: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
checkCLKandBIN();
|
|
cae: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
checkCLKandBIN();
|
|
cb2: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
checkCLKandBIN();
|
|
cb6: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
checkCLKandBIN();
|
|
cba: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
checkCLKandBIN();
|
|
cbe: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
checkCLKandBIN();
|
|
cc2: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
checkCLKandBIN();
|
|
cc6: 0e 94 b9 02 call 0x572 ; 0x572 <checkCLKandBIN()>
|
|
cca: 80 91 42 01 lds r24, 0x0142 ; 0x800142 <bitfieldA>
|
|
cce: 20 91 43 01 lds r18, 0x0143 ; 0x800143 <bitfieldA+0x1>
|
|
cd2: 92 2f mov r25, r18
|
|
cd4: 9f 73 andi r25, 0x3F ; 63
|
|
cd6: 24 e0 ldi r18, 0x04 ; 4
|
|
lc.setDigit(0,1,(byte)tens,false);
|
|
lc.setDigit(0,0,(byte)ones,false);
|
|
}
|
|
|
|
void ConvertArraytoBin (void){
|
|
for(x=4;x<21;x++){
|
|
cd8: 25 31 cpi r18, 0x15 ; 21
|
|
cda: a9 f0 breq .+42 ; 0xd06 <main+0x212>
|
|
if(hzbinval[x] == 1){
|
|
cdc: 42 2f mov r20, r18
|
|
cde: 50 e0 ldi r21, 0x00 ; 0
|
|
ce0: fa 01 movw r30, r20
|
|
ce2: ed 5d subi r30, 0xDD ; 221
|
|
ce4: fe 4f sbci r31, 0xFE ; 254
|
|
ce6: 30 81 ld r19, Z
|
|
ce8: 31 30 cpi r19, 0x01 ; 1
|
|
cea: 59 f4 brne .+22 ; 0xd02 <main+0x20e>
|
|
bitfieldA.mainstwo = bitfieldA.mainstwo | (0b0000000000000000000001 << (x - 3));
|
|
cec: 43 50 subi r20, 0x03 ; 3
|
|
cee: 51 09 sbc r21, r1
|
|
cf0: b7 01 movw r22, r14
|
|
cf2: 02 c0 rjmp .+4 ; 0xcf8 <main+0x204>
|
|
cf4: 66 0f add r22, r22
|
|
cf6: 77 1f adc r23, r23
|
|
cf8: 4a 95 dec r20
|
|
cfa: e2 f7 brpl .-8 ; 0xcf4 <main+0x200>
|
|
cfc: 86 2b or r24, r22
|
|
cfe: 97 2b or r25, r23
|
|
d00: 9f 73 andi r25, 0x3F ; 63
|
|
d02: 2f 5f subi r18, 0xFF ; 255
|
|
d04: e9 cf rjmp .-46 ; 0xcd8 <main+0x1e4>
|
|
d06: 80 93 42 01 sts 0x0142, r24 ; 0x800142 <bitfieldA>
|
|
d0a: 39 2f mov r19, r25
|
|
d0c: 3f 73 andi r19, 0x3F ; 63
|
|
d0e: 90 91 43 01 lds r25, 0x0143 ; 0x800143 <bitfieldA+0x1>
|
|
d12: 90 7c andi r25, 0xC0 ; 192
|
|
d14: 93 2b or r25, r19
|
|
d16: 90 93 43 01 sts 0x0143, r25 ; 0x800143 <bitfieldA+0x1>
|
|
d1a: 20 93 41 01 sts 0x0141, r18 ; 0x800141 <x>
|
|
}
|
|
}
|
|
//Serial.println(bitfieldA.mainstwo,BIN);
|
|
|
|
|
|
temp = bitfieldA.mainstwo >> 1;
|
|
d1e: 9c 01 movw r18, r24
|
|
d20: 3f 73 andi r19, 0x3F ; 63
|
|
d22: 35 95 asr r19
|
|
d24: 27 95 ror r18
|
|
|
|
//almost, but no cigar. has timing issues.
|
|
//ugly hack time
|
|
temp = temp & 0b1011111111111;
|
|
d26: 37 71 andi r19, 0x17 ; 23
|
|
//results in a clock that is right most of the time.
|
|
//but wrong every 20 or so counts
|
|
//todo: fix timing of duino by removing digital read for
|
|
//direct port reads
|
|
if(temp == 5047){
|
|
d28: 27 3b cpi r18, 0xB7 ; 183
|
|
d2a: 73 e1 ldi r23, 0x13 ; 19
|
|
d2c: 37 07 cpc r19, r23
|
|
d2e: 29 f0 breq .+10 ; 0xd3a <main+0x246>
|
|
|
|
temp = bitfieldA.mainstwo >> 1;
|
|
|
|
//almost, but no cigar. has timing issues.
|
|
//ugly hack time
|
|
temp = temp & 0b1011111111111;
|
|
d30: 30 93 22 01 sts 0x0122, r19 ; 0x800122 <temp+0x1>
|
|
d34: 20 93 21 01 sts 0x0121, r18 ; 0x800121 <temp>
|
|
d38: 04 c0 rjmp .+8 ; 0xd42 <main+0x24e>
|
|
//results in a clock that is right most of the time.
|
|
//but wrong every 20 or so counts
|
|
//todo: fix timing of duino by removing digital read for
|
|
//direct port reads
|
|
if(temp == 5047){
|
|
temp = 5998; //something, something, premature optimization...
|
|
d3a: 30 92 22 01 sts 0x0122, r3 ; 0x800122 <temp+0x1>
|
|
d3e: 20 92 21 01 sts 0x0121, r2 ; 0x800121 <temp>
|
|
}
|
|
if(temp == 5048){
|
|
d42: 80 91 21 01 lds r24, 0x0121 ; 0x800121 <temp>
|
|
d46: 90 91 22 01 lds r25, 0x0122 ; 0x800122 <temp+0x1>
|
|
d4a: 88 3b cpi r24, 0xB8 ; 184
|
|
d4c: 93 41 sbci r25, 0x13 ; 19
|
|
d4e: 21 f4 brne .+8 ; 0xd58 <main+0x264>
|
|
temp = 6000; //LUTs
|
|
d50: d0 92 22 01 sts 0x0122, r13 ; 0x800122 <temp+0x1>
|
|
d54: c0 92 21 01 sts 0x0121, r12 ; 0x800121 <temp>
|
|
n = -n;
|
|
return printNumber(n, 10) + t;
|
|
}
|
|
return printNumber(n, 10);
|
|
} else {
|
|
return printNumber(n, base);
|
|
d58: 60 91 21 01 lds r22, 0x0121 ; 0x800121 <temp>
|
|
d5c: 70 91 22 01 lds r23, 0x0122 ; 0x800122 <temp+0x1>
|
|
d60: 07 2e mov r0, r23
|
|
d62: 00 0c add r0, r0
|
|
d64: 88 0b sbc r24, r24
|
|
d66: 99 0b sbc r25, r25
|
|
d68: 42 e0 ldi r20, 0x02 ; 2
|
|
d6a: 0e 94 da 03 call 0x7b4 ; 0x7b4 <Print::printNumber(unsigned long, unsigned char) [clone .constprop.7]>
|
|
return x.printTo(*this);
|
|
}
|
|
|
|
size_t Print::println(void)
|
|
{
|
|
return write("\r\n");
|
|
d6e: 82 e1 ldi r24, 0x12 ; 18
|
|
d70: 91 e0 ldi r25, 0x01 ; 1
|
|
d72: 0e 94 c8 03 call 0x790 ; 0x790 <Print::write(char const*) [clone .constprop.10]>
|
|
}
|
|
|
|
Serial.println(temp,BIN);
|
|
Serial.println(temp,DEC);
|
|
d76: 40 90 21 01 lds r4, 0x0121 ; 0x800121 <temp>
|
|
d7a: 50 90 22 01 lds r5, 0x0122 ; 0x800122 <temp+0x1>
|
|
return print((unsigned long) b, base);
|
|
}
|
|
|
|
size_t Print::print(int n, int base)
|
|
{
|
|
return print((long) n, base);
|
|
d7e: 05 2c mov r0, r5
|
|
d80: 00 0c add r0, r0
|
|
d82: 66 08 sbc r6, r6
|
|
d84: 77 08 sbc r7, r7
|
|
size_t Print::print(long n, int base)
|
|
{
|
|
if (base == 0) {
|
|
return write(n);
|
|
} else if (base == 10) {
|
|
if (n < 0) {
|
|
d86: 77 fe sbrs r7, 7
|
|
d88: 14 c0 rjmp .+40 ; 0xdb2 <main+0x2be>
|
|
return write(str);
|
|
}
|
|
|
|
size_t Print::print(char c)
|
|
{
|
|
return write(c);
|
|
d8a: e0 91 47 01 lds r30, 0x0147 ; 0x800147 <Serial>
|
|
d8e: f0 91 48 01 lds r31, 0x0148 ; 0x800148 <Serial+0x1>
|
|
d92: 01 90 ld r0, Z+
|
|
d94: f0 81 ld r31, Z
|
|
d96: e0 2d mov r30, r0
|
|
d98: 6d e2 ldi r22, 0x2D ; 45
|
|
d9a: 87 e4 ldi r24, 0x47 ; 71
|
|
d9c: 91 e0 ldi r25, 0x01 ; 1
|
|
d9e: 09 95 icall
|
|
if (base == 0) {
|
|
return write(n);
|
|
} else if (base == 10) {
|
|
if (n < 0) {
|
|
int t = print('-');
|
|
n = -n;
|
|
da0: 66 27 eor r22, r22
|
|
da2: 77 27 eor r23, r23
|
|
da4: cb 01 movw r24, r22
|
|
da6: 64 19 sub r22, r4
|
|
da8: 75 09 sbc r23, r5
|
|
daa: 86 09 sbc r24, r6
|
|
dac: 97 09 sbc r25, r7
|
|
return printNumber(n, 10) + t;
|
|
dae: 4a e0 ldi r20, 0x0A ; 10
|
|
db0: 03 c0 rjmp .+6 ; 0xdb8 <main+0x2c4>
|
|
}
|
|
return printNumber(n, 10);
|
|
db2: 4a e0 ldi r20, 0x0A ; 10
|
|
db4: c3 01 movw r24, r6
|
|
db6: b2 01 movw r22, r4
|
|
db8: 0e 94 da 03 call 0x7b4 ; 0x7b4 <Print::printNumber(unsigned long, unsigned char) [clone .constprop.7]>
|
|
return x.printTo(*this);
|
|
}
|
|
|
|
size_t Print::println(void)
|
|
{
|
|
return write("\r\n");
|
|
dbc: 82 e1 ldi r24, 0x12 ; 18
|
|
dbe: 91 e0 ldi r25, 0x01 ; 1
|
|
dc0: 0e 94 c8 03 call 0x790 ; 0x790 <Print::write(char const*) [clone .constprop.10]>
|
|
return write(s.c_str(), s.length());
|
|
}
|
|
|
|
size_t Print::print(const char str[])
|
|
{
|
|
return write(str);
|
|
dc4: 83 e1 ldi r24, 0x13 ; 19
|
|
dc6: 91 e0 ldi r25, 0x01 ; 1
|
|
dc8: 0e 94 c8 03 call 0x790 ; 0x790 <Print::write(char const*) [clone .constprop.10]>
|
|
Serial.print("\n");
|
|
|
|
lc.clearDisplay(0);
|
|
dcc: 60 e0 ldi r22, 0x00 ; 0
|
|
dce: 70 e0 ldi r23, 0x00 ; 0
|
|
dd0: 84 ee ldi r24, 0xE4 ; 228
|
|
dd2: 91 e0 ldi r25, 0x01 ; 1
|
|
dd4: 0e 94 92 03 call 0x724 ; 0x724 <LedControl::clearDisplay(int)>
|
|
printNumber(temp);
|
|
dd8: 80 91 21 01 lds r24, 0x0121 ; 0x800121 <temp>
|
|
ddc: 90 91 22 01 lds r25, 0x0122 ; 0x800122 <temp+0x1>
|
|
int tens;
|
|
int hundreds;
|
|
int thousands;
|
|
boolean negative;
|
|
|
|
if(v < -9999 || v > 9999)
|
|
de0: 9c 01 movw r18, r24
|
|
de2: 21 5f subi r18, 0xF1 ; 241
|
|
de4: 38 4d sbci r19, 0xD8 ; 216
|
|
de6: 2f 31 cpi r18, 0x1F ; 31
|
|
de8: 3e 44 sbci r19, 0x4E ; 78
|
|
dea: 30 f5 brcc .+76 ; 0xe38 <main+0x344>
|
|
dec: 97 ff sbrs r25, 7
|
|
dee: 03 c0 rjmp .+6 ; 0xdf6 <main+0x302>
|
|
df0: 91 95 neg r25
|
|
df2: 81 95 neg r24
|
|
df4: 91 09 sbc r25, r1
|
|
if(v<0) {
|
|
negative=true;
|
|
v=v*-1;
|
|
}
|
|
ones=v%10;
|
|
v=v/10;
|
|
df6: be 01 movw r22, r28
|
|
df8: 0e 94 53 07 call 0xea6 ; 0xea6 <__divmodhi4>
|
|
dfc: 78 2e mov r7, r24
|
|
tens=v%10;
|
|
v=v/10;
|
|
dfe: cb 01 movw r24, r22
|
|
e00: be 01 movw r22, r28
|
|
e02: 0e 94 53 07 call 0xea6 ; 0xea6 <__divmodhi4>
|
|
e06: 68 2e mov r6, r24
|
|
hundreds=v%10;
|
|
v=v/10;
|
|
e08: cb 01 movw r24, r22
|
|
e0a: be 01 movw r22, r28
|
|
e0c: 0e 94 53 07 call 0xea6 ; 0xea6 <__divmodhi4>
|
|
e10: 58 2e mov r5, r24
|
|
else {
|
|
//print a blank in the sign column
|
|
lc.setChar(0,4,' ',false);
|
|
}*/
|
|
//Now print the number digit by digit
|
|
lc.setDigit(0,3,(byte)thousands,false);
|
|
e12: 83 e0 ldi r24, 0x03 ; 3
|
|
e14: 90 e0 ldi r25, 0x00 ; 0
|
|
e16: 0e 94 74 03 call 0x6e8 ; 0x6e8 <LedControl::setDigit(int, int, unsigned char, bool) [clone .constprop.15]>
|
|
lc.setDigit(0,2,(byte)hundreds,false);
|
|
e1a: 65 2d mov r22, r5
|
|
e1c: 82 e0 ldi r24, 0x02 ; 2
|
|
e1e: 90 e0 ldi r25, 0x00 ; 0
|
|
e20: 0e 94 74 03 call 0x6e8 ; 0x6e8 <LedControl::setDigit(int, int, unsigned char, bool) [clone .constprop.15]>
|
|
lc.setDigit(0,1,(byte)tens,false);
|
|
e24: 66 2d mov r22, r6
|
|
e26: 81 e0 ldi r24, 0x01 ; 1
|
|
e28: 90 e0 ldi r25, 0x00 ; 0
|
|
e2a: 0e 94 74 03 call 0x6e8 ; 0x6e8 <LedControl::setDigit(int, int, unsigned char, bool) [clone .constprop.15]>
|
|
lc.setDigit(0,0,(byte)ones,false);
|
|
e2e: 67 2d mov r22, r7
|
|
e30: 80 e0 ldi r24, 0x00 ; 0
|
|
e32: 90 e0 ldi r25, 0x00 ; 0
|
|
e34: 0e 94 74 03 call 0x6e8 ; 0x6e8 <LedControl::setDigit(int, int, unsigned char, bool) [clone .constprop.15]>
|
|
return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond());
|
|
}
|
|
|
|
void delay(unsigned long ms)
|
|
{
|
|
uint32_t start = micros();
|
|
e38: 0e 94 94 02 call 0x528 ; 0x528 <micros>
|
|
e3c: 4b 01 movw r8, r22
|
|
e3e: 5c 01 movw r10, r24
|
|
e40: 8a ef ldi r24, 0xFA ; 250
|
|
e42: 48 2e mov r4, r24
|
|
e44: 51 2c mov r5, r1
|
|
e46: 61 2c mov r6, r1
|
|
e48: 71 2c mov r7, r1
|
|
|
|
while (ms > 0) {
|
|
yield();
|
|
while ( ms > 0 && (micros() - start) >= 1000) {
|
|
e4a: 0e 94 94 02 call 0x528 ; 0x528 <micros>
|
|
e4e: dc 01 movw r26, r24
|
|
e50: cb 01 movw r24, r22
|
|
e52: 88 19 sub r24, r8
|
|
e54: 99 09 sbc r25, r9
|
|
e56: aa 09 sbc r26, r10
|
|
e58: bb 09 sbc r27, r11
|
|
e5a: 88 3e cpi r24, 0xE8 ; 232
|
|
e5c: 93 40 sbci r25, 0x03 ; 3
|
|
e5e: a1 05 cpc r26, r1
|
|
e60: b1 05 cpc r27, r1
|
|
e62: 58 f0 brcs .+22 ; 0xe7a <main+0x386>
|
|
ms--;
|
|
e64: 61 e0 ldi r22, 0x01 ; 1
|
|
e66: 46 1a sub r4, r22
|
|
e68: 51 08 sbc r5, r1
|
|
e6a: 61 08 sbc r6, r1
|
|
e6c: 71 08 sbc r7, r1
|
|
start += 1000;
|
|
e6e: 78 ee ldi r23, 0xE8 ; 232
|
|
e70: 87 0e add r8, r23
|
|
e72: 73 e0 ldi r23, 0x03 ; 3
|
|
e74: 97 1e adc r9, r23
|
|
e76: a1 1c adc r10, r1
|
|
e78: b1 1c adc r11, r1
|
|
{
|
|
uint32_t start = micros();
|
|
|
|
while (ms > 0) {
|
|
yield();
|
|
while ( ms > 0 && (micros() - start) >= 1000) {
|
|
e7a: 41 14 cp r4, r1
|
|
e7c: 51 04 cpc r5, r1
|
|
e7e: 61 04 cpc r6, r1
|
|
e80: 71 04 cpc r7, r1
|
|
e82: 19 f7 brne .-58 ; 0xe4a <main+0x356>
|
|
checkCLKandBIN();
|
|
checkCLKandBIN();
|
|
checkCLKandBIN();
|
|
//Serial.println(clkval); //outputs 19 or 20
|
|
ConvertArraytoBin();
|
|
mainsfreq = 0;
|
|
e84: 10 92 45 01 sts 0x0145, r1 ; 0x800145 <mainsfreq+0x1>
|
|
e88: 10 92 44 01 sts 0x0144, r1 ; 0x800144 <mainsfreq>
|
|
bitfieldA.mainstwo = 0;
|
|
e8c: 10 92 42 01 sts 0x0142, r1 ; 0x800142 <bitfieldA>
|
|
e90: 80 91 43 01 lds r24, 0x0143 ; 0x800143 <bitfieldA+0x1>
|
|
e94: 80 7c andi r24, 0xC0 ; 192
|
|
e96: 80 93 43 01 sts 0x0143, r24 ; 0x800143 <bitfieldA+0x1>
|
|
|
|
|
|
#endif
|
|
|
|
// busy wait
|
|
__asm__ __volatile__ (
|
|
e9a: c8 01 movw r24, r16
|
|
e9c: 01 97 sbiw r24, 0x01 ; 1
|
|
e9e: f1 f7 brne .-4 ; 0xe9c <main+0x3a8>
|
|
|
|
setup();
|
|
|
|
for (;;) {
|
|
loop();
|
|
if (serialEventRun) serialEventRun();
|
|
ea0: 0e 94 cc 01 call 0x398 ; 0x398 <serialEventRun()>
|
|
ea4: de ce rjmp .-580 ; 0xc62 <main+0x16e>
|
|
|
|
00000ea6 <__divmodhi4>:
|
|
ea6: 97 fb bst r25, 7
|
|
ea8: 07 2e mov r0, r23
|
|
eaa: 16 f4 brtc .+4 ; 0xeb0 <__divmodhi4+0xa>
|
|
eac: 00 94 com r0
|
|
eae: 07 d0 rcall .+14 ; 0xebe <__divmodhi4_neg1>
|
|
eb0: 77 fd sbrc r23, 7
|
|
eb2: 09 d0 rcall .+18 ; 0xec6 <__divmodhi4_neg2>
|
|
eb4: 0e 94 89 07 call 0xf12 ; 0xf12 <__udivmodhi4>
|
|
eb8: 07 fc sbrc r0, 7
|
|
eba: 05 d0 rcall .+10 ; 0xec6 <__divmodhi4_neg2>
|
|
ebc: 3e f4 brtc .+14 ; 0xecc <__divmodhi4_exit>
|
|
|
|
00000ebe <__divmodhi4_neg1>:
|
|
ebe: 90 95 com r25
|
|
ec0: 81 95 neg r24
|
|
ec2: 9f 4f sbci r25, 0xFF ; 255
|
|
ec4: 08 95 ret
|
|
|
|
00000ec6 <__divmodhi4_neg2>:
|
|
ec6: 70 95 com r23
|
|
ec8: 61 95 neg r22
|
|
eca: 7f 4f sbci r23, 0xFF ; 255
|
|
|
|
00000ecc <__divmodhi4_exit>:
|
|
ecc: 08 95 ret
|
|
|
|
00000ece <__udivmodsi4>:
|
|
ece: a1 e2 ldi r26, 0x21 ; 33
|
|
ed0: 1a 2e mov r1, r26
|
|
ed2: aa 1b sub r26, r26
|
|
ed4: bb 1b sub r27, r27
|
|
ed6: fd 01 movw r30, r26
|
|
ed8: 0d c0 rjmp .+26 ; 0xef4 <__udivmodsi4_ep>
|
|
|
|
00000eda <__udivmodsi4_loop>:
|
|
eda: aa 1f adc r26, r26
|
|
edc: bb 1f adc r27, r27
|
|
ede: ee 1f adc r30, r30
|
|
ee0: ff 1f adc r31, r31
|
|
ee2: a2 17 cp r26, r18
|
|
ee4: b3 07 cpc r27, r19
|
|
ee6: e4 07 cpc r30, r20
|
|
ee8: f5 07 cpc r31, r21
|
|
eea: 20 f0 brcs .+8 ; 0xef4 <__udivmodsi4_ep>
|
|
eec: a2 1b sub r26, r18
|
|
eee: b3 0b sbc r27, r19
|
|
ef0: e4 0b sbc r30, r20
|
|
ef2: f5 0b sbc r31, r21
|
|
|
|
00000ef4 <__udivmodsi4_ep>:
|
|
ef4: 66 1f adc r22, r22
|
|
ef6: 77 1f adc r23, r23
|
|
ef8: 88 1f adc r24, r24
|
|
efa: 99 1f adc r25, r25
|
|
efc: 1a 94 dec r1
|
|
efe: 69 f7 brne .-38 ; 0xeda <__udivmodsi4_loop>
|
|
f00: 60 95 com r22
|
|
f02: 70 95 com r23
|
|
f04: 80 95 com r24
|
|
f06: 90 95 com r25
|
|
f08: 9b 01 movw r18, r22
|
|
f0a: ac 01 movw r20, r24
|
|
f0c: bd 01 movw r22, r26
|
|
f0e: cf 01 movw r24, r30
|
|
f10: 08 95 ret
|
|
|
|
00000f12 <__udivmodhi4>:
|
|
f12: aa 1b sub r26, r26
|
|
f14: bb 1b sub r27, r27
|
|
f16: 51 e1 ldi r21, 0x11 ; 17
|
|
f18: 07 c0 rjmp .+14 ; 0xf28 <__udivmodhi4_ep>
|
|
|
|
00000f1a <__udivmodhi4_loop>:
|
|
f1a: aa 1f adc r26, r26
|
|
f1c: bb 1f adc r27, r27
|
|
f1e: a6 17 cp r26, r22
|
|
f20: b7 07 cpc r27, r23
|
|
f22: 10 f0 brcs .+4 ; 0xf28 <__udivmodhi4_ep>
|
|
f24: a6 1b sub r26, r22
|
|
f26: b7 0b sbc r27, r23
|
|
|
|
00000f28 <__udivmodhi4_ep>:
|
|
f28: 88 1f adc r24, r24
|
|
f2a: 99 1f adc r25, r25
|
|
f2c: 5a 95 dec r21
|
|
f2e: a9 f7 brne .-22 ; 0xf1a <__udivmodhi4_loop>
|
|
f30: 80 95 com r24
|
|
f32: 90 95 com r25
|
|
f34: bc 01 movw r22, r24
|
|
f36: cd 01 movw r24, r26
|
|
f38: 08 95 ret
|
|
|
|
00000f3a <__tablejump2__>:
|
|
f3a: ee 0f add r30, r30
|
|
f3c: ff 1f adc r31, r31
|
|
f3e: 05 90 lpm r0, Z+
|
|
f40: f4 91 lpm r31, Z
|
|
f42: e0 2d mov r30, r0
|
|
f44: 09 94 ijmp
|
|
|
|
00000f46 <abort>:
|
|
f46: 81 e0 ldi r24, 0x01 ; 1
|
|
f48: 90 e0 ldi r25, 0x00 ; 0
|
|
f4a: f8 94 cli
|
|
f4c: 0c 94 a8 07 jmp 0xf50 ; 0xf50 <_exit>
|
|
|
|
00000f50 <_exit>:
|
|
f50: f8 94 cli
|
|
|
|
00000f52 <__stop_program>:
|
|
f52: ff cf rjmp .-2 ; 0xf52 <__stop_program>
|