Brat4791, Вы же сами понимаете, что не работать тут нечему. В нормальной ситуации Ваш пример вполне себе успешно выдаёт Hello.
Значит есть ещё какой-то нестандартный фактор. Не крутили чего-нибудь с настройками com-портов в винде? С какими-нибудь языковыми настройками, шрифтами консоли? Попробуйте эти ардуинки на другом компе. Проблему, как уже писали выше, только опытным путём локализовать можно, отсекая всё по очереди. Из серии танцев с бубнами можно попробовать при заданной скорости в скетче поперебирать скорости в мониторе. И да, плата точно не wavgat какой-нибудь?
Не нужно про датчик. Если у Вас проблемы с монитором порта, то и приводите код, в котором нет ничего кроме работы с монитором порта.
Сократите свой пример и выложите здесь его скетч и то, что он выводит в монитор порта.
Ошибку надо искать, отсекая все лишнее. В данном случае лишнее - это работа с датчиком.
Если же окажется, что сконструировать пример, демонстрирующий ошибку, без датчика не получится, то велика вероятность, что Ваш предварительный диагноз не подтвердился, и проблема на самом деле не с монитором, а с датчиком.
Brat4791 пишет:
ни один скейч связанный с терминалом не работает
так же заливал скейч с примеров чисто для монитора порта
все так же остается кракозябры
char i[]="\110\145\154\154\157"; // Определяем строку из 5 кодов символов "Hello". Символ конца строки добавляется автоматически.
void setup(){ //
Serial.begin(9600); // Инициируем работу шины UART на скорости 9600 бит/сек.
Serial.println(i); // Отправляем строку в монитор последовательного порта.
} //
void loop(){ //
} //
1. Brat4791, я Вам дважды писал (в сообщениях №40 и №47), что приводить надо и скетч и то, что выводится в монитор. Где?
2. Откуда взялась эта странная строка кодов? Вы сами хоть понимаете, что комментарии к первой строке совершенно не соответствуют действительности? Эта строка и должна выводить "кракозябры".
2. Откуда взялась эта странная строка кодов? Вы сами хоть понимаете, что комментарии к первой строке совершенно не соответствуют действительности? Эта строка и должна выводить "кракозябры".
Нет, это действительно Hello записанное восьмеричным кодом. Но зачем?
2. Откуда взялась эта странная строка кодов? Вы сами хоть понимаете, что комментарии к первой строке совершенно не соответствуют действительности? Эта строка и должна выводить "кракозябры".
Нет, это действительно Hello записанное восьмеричным кодом. Но зачем?
Ну, значит, я плохо знаю Си. Я почему-то считал, что в Си числа в восьмеричном коде записываются с ведущим нулем.
PS. Проверил в VC - действительно Hello. Пошел учить Си...(((
Может не надо учить? Может сначала нолики перед числами поставить и проверить?
Учить как раз надо.
Выяснилось, что число должно быть не просто восмеричным, но обязательно трехзначным внезависимости от того, будет там ведущий ноль или нет. Что, впрочем, логично: строка \12345 понимается как char(oct123),'4','5', а строка \012345 - как строка char(oct12),'3','4','5'.
"Восьмеричная escape-последовательность — это обратная косая черта, за которой следует последовательность из одной до трех восьмеричных цифр. Восьмеричная escape-последовательность завершается на первом символе, который не является восьмеричной цифрой, если он встречается раньше, чем третья цифра. Наибольшее возможное восьмеричное значение — \377 ."
char i[]="\110\145\154\154\157"; // Определяем строку из 5 кодов символов "Hello". Символ конца строки добавляется автоматически.
Это в какой кодировке ?
покажите что выведет - Serial.println("Hello world");
брал из примера ардуины
вот что монитор выдал
а просмотр в 16-ричном виде есть в мониторе ?
а просмотр в 16-ричном виде есть в мониторе ?
нет ни каких настроек
Так что там на выводе при Serial.println("01234 Hello world 56789");
Brat4791, Вы же сами понимаете, что не работать тут нечему. В нормальной ситуации Ваш пример вполне себе успешно выдаёт Hello.
Значит есть ещё какой-то нестандартный фактор. Не крутили чего-нибудь с настройками com-портов в винде? С какими-нибудь языковыми настройками, шрифтами консоли? Попробуйте эти ардуинки на другом компе. Проблему, как уже писали выше, только опытным путём локализовать можно, отсекая всё по очереди. Из серии танцев с бубнами можно попробовать при заданной скорости в скетче поперебирать скорости в мониторе. И да, плата точно не wavgat какой-нибудь?
Не нужно про датчик. Если у Вас проблемы с монитором порта, то и приводите код, в котором нет ничего кроме работы с монитором порта.
Сократите свой пример и выложите здесь его скетч и то, что он выводит в монитор порта.
Ошибку надо искать, отсекая все лишнее. В данном случае лишнее - это работа с датчиком.
Если же окажется, что сконструировать пример, демонстрирующий ошибку, без датчика не получится, то велика вероятность, что Ваш предварительный диагноз не подтвердился, и проблема на самом деле не с монитором, а с датчиком.
ни один скейч связанный с терминалом не работает
так же заливал скейч с примеров чисто для монитора порта
все так же остается кракозябры
char i[]="\110\145\154\154\157"; // Определяем строку из 5 кодов символов "Hello". Символ конца строки добавляется автоматически. void setup(){ // Serial.begin(9600); // Инициируем работу шины UART на скорости 9600 бит/сек. Serial.println(i); // Отправляем строку в монитор последовательного порта. } // void loop(){ // } //1. Brat4791, я Вам дважды писал (в сообщениях №40 и №47), что приводить надо и скетч и то, что выводится в монитор. Где?
2. Откуда взялась эта странная строка кодов? Вы сами хоть понимаете, что комментарии к первой строке совершенно не соответствуют действительности? Эта строка и должна выводить "кракозябры".
2. Откуда взялась эта странная строка кодов? Вы сами хоть понимаете, что комментарии к первой строке совершенно не соответствуют действительности? Эта строка и должна выводить "кракозябры".
Нет, это действительно Hello записанное восьмеричным кодом. Но зачем?
2. Откуда взялась эта странная строка кодов? Вы сами хоть понимаете, что комментарии к первой строке совершенно не соответствуют действительности? Эта строка и должна выводить "кракозябры".
Нет, это действительно Hello записанное восьмеричным кодом. Но зачем?
Ну, значит, я плохо знаю Си. Я почему-то считал, что в Си числа в восьмеричном коде записываются с ведущим нулем.
PS. Проверил в VC - действительно Hello. Пошел учить Си...(((
Может не надо учить? Может сначала нолики перед числами поставить и проверить? Скомпилил, дизассемблировал, стоку в elf не нашёл. Что за дела?
test_oct.ino.elf: file format elf32-avr Disassembly of section .text: 00000000 <__vectors>: 0: 0c 94 35 00 jmp 0x6a ; 0x6a <__ctors_end> 4: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 8: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> c: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 10: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 14: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 18: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 1c: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 20: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 24: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 28: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 2c: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 30: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 34: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 38: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 3c: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 40: 0c 94 6c 01 jmp 0x2d8 ; 0x2d8 <__vector_16> 44: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 48: 0c 94 dc 01 jmp 0x3b8 ; 0x3b8 <__vector_18> 4c: 0c 94 b6 01 jmp 0x36c ; 0x36c <__vector_19> 50: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 54: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 58: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 5c: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 60: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 64: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt> 00000068 <__ctors_start>: 68: a8 02 muls r26, r24 0000006a <__ctors_end>: 6a: 11 24 eor r1, r1 6c: 1f be out 0x3f, r1 ; 63 6e: cf ef ldi r28, 0xFF ; 255 70: d8 e0 ldi r29, 0x08 ; 8 72: de bf out 0x3e, r29 ; 62 74: cd bf out 0x3d, r28 ; 61 00000076 <__do_copy_data>: 76: 11 e0 ldi r17, 0x01 ; 1 78: a0 e0 ldi r26, 0x00 ; 0 7a: b1 e0 ldi r27, 0x01 ; 1 7c: ea eb ldi r30, 0xBA ; 186 7e: f5 e0 ldi r31, 0x05 ; 5 80: 02 c0 rjmp .+4 ; 0x86 <__do_copy_data+0x10> 82: 05 90 lpm r0, Z+ 84: 0d 92 st X+, r0 86: ac 31 cpi r26, 0x1C ; 28 88: b1 07 cpc r27, r17 8a: d9 f7 brne .-10 ; 0x82 <__do_copy_data+0xc> 0000008c <__do_clear_bss>: 8c: 21 e0 ldi r18, 0x01 ; 1 8e: ac e1 ldi r26, 0x1C ; 28 90: b1 e0 ldi r27, 0x01 ; 1 92: 01 c0 rjmp .+2 ; 0x96 <.do_clear_bss_start> 00000094 <.do_clear_bss_loop>: 94: 1d 92 st X+, r1 00000096 <.do_clear_bss_start>: 96: a2 3c cpi r26, 0xC2 ; 194 98: b2 07 cpc r27, r18 9a: e1 f7 brne .-8 ; 0x94 <.do_clear_bss_loop> 0000009c <__do_global_ctors>: 9c: 10 e0 ldi r17, 0x00 ; 0 9e: c5 e3 ldi r28, 0x35 ; 53 a0: d0 e0 ldi r29, 0x00 ; 0 a2: 04 c0 rjmp .+8 ; 0xac <__do_global_ctors+0x10> a4: 21 97 sbiw r28, 0x01 ; 1 a6: fe 01 movw r30, r28 a8: 0e 94 d5 02 call 0x5aa ; 0x5aa <__tablejump2__> ac: c4 33 cpi r28, 0x34 ; 52 ae: d1 07 cpc r29, r17 b0: c9 f7 brne .-14 ; 0xa4 <__do_global_ctors+0x8> b2: 0e 94 0e 02 call 0x41c ; 0x41c <main> b6: 0c 94 db 02 jmp 0x5b6 ; 0x5b6 <_exit> 000000ba <__bad_interrupt>: ba: 0c 94 00 00 jmp 0 ; 0x0 <__vectors> 000000be <_ZN5Print5writeEPKhj>: // Public Methods ////////////////////////////////////////////////////////////// /* default implementation: may be overridden */ size_t Print::write(const uint8_t *buffer, size_t size) { be: af 92 push r10 c0: bf 92 push r11 c2: cf 92 push r12 c4: df 92 push r13 c6: ef 92 push r14 c8: ff 92 push r15 ca: 0f 93 push r16 cc: 1f 93 push r17 ce: cf 93 push r28 d0: df 93 push r29 d2: 6c 01 movw r12, r24 d4: 7b 01 movw r14, r22 d6: 8b 01 movw r16, r22 d8: 04 0f add r16, r20 da: 15 1f adc r17, r21 dc: eb 01 movw r28, r22 de: 5e 01 movw r10, r28 e0: ae 18 sub r10, r14 e2: bf 08 sbc r11, r15 size_t n = 0; while (size--) { e4: c0 17 cp r28, r16 e6: d1 07 cpc r29, r17 e8: 59 f0 breq .+22 ; 0x100 <_ZN5Print5writeEPKhj+0x42> if (write(*buffer++)) n++; ea: 69 91 ld r22, Y+ ec: d6 01 movw r26, r12 ee: ed 91 ld r30, X+ f0: fc 91 ld r31, X f2: 01 90 ld r0, Z+ f4: f0 81 ld r31, Z f6: e0 2d mov r30, r0 f8: c6 01 movw r24, r12 fa: 09 95 icall fc: 89 2b or r24, r25 fe: 79 f7 brne .-34 ; 0xde <_ZN5Print5writeEPKhj+0x20> else break; } return n; } 100: c5 01 movw r24, r10 102: df 91 pop r29 104: cf 91 pop r28 106: 1f 91 pop r17 108: 0f 91 pop r16 10a: ff 90 pop r15 10c: ef 90 pop r14 10e: df 90 pop r13 110: cf 90 pop r12 112: bf 90 pop r11 114: af 90 pop r10 116: 08 95 ret 00000118 <_ZN14HardwareSerial17availableForWriteEv>: { tx_buffer_index_t head; tx_buffer_index_t tail; TX_BUFFER_ATOMIC { head = _tx_buffer_head; 118: fc 01 movw r30, r24 11a: 53 8d ldd r21, Z+27 ; 0x1b tail = _tx_buffer_tail; 11c: 44 8d ldd r20, Z+28 ; 0x1c 11e: 25 2f mov r18, r21 120: 30 e0 ldi r19, 0x00 ; 0 122: 84 2f mov r24, r20 124: 90 e0 ldi r25, 0x00 ; 0 } if (head >= tail) return SERIAL_TX_BUFFER_SIZE - 1 - head + tail; 126: 82 1b sub r24, r18 128: 93 0b sbc r25, r19 12a: 54 17 cp r21, r20 12c: 10 f0 brcs .+4 ; 0x132 <_ZN14HardwareSerial17availableForWriteEv+0x1a> 12e: cf 96 adiw r24, 0x3f ; 63 130: 08 95 ret return tail - head - 1; 132: 01 97 sbiw r24, 0x01 ; 1 } 134: 08 95 ret 00000136 <_ZN14HardwareSerial4readEv>: return _rx_buffer[_rx_buffer_tail]; } } int HardwareSerial::read(void) { 136: 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) { 138: 91 8d ldd r25, Z+25 ; 0x19 13a: 82 8d ldd r24, Z+26 ; 0x1a 13c: 98 17 cp r25, r24 13e: 61 f0 breq .+24 ; 0x158 <_ZN14HardwareSerial4readEv+0x22> return -1; } else { unsigned char c = _rx_buffer[_rx_buffer_tail]; 140: a2 8d ldd r26, Z+26 ; 0x1a 142: ae 0f add r26, r30 144: bf 2f mov r27, r31 146: b1 1d adc r27, r1 148: 5d 96 adiw r26, 0x1d ; 29 14a: 8c 91 ld r24, X _rx_buffer_tail = (rx_buffer_index_t)(_rx_buffer_tail + 1) % SERIAL_RX_BUFFER_SIZE; 14c: 92 8d ldd r25, Z+26 ; 0x1a 14e: 9f 5f subi r25, 0xFF ; 255 150: 9f 73 andi r25, 0x3F ; 63 152: 92 8f std Z+26, r25 ; 0x1a return c; 154: 90 e0 ldi r25, 0x00 ; 0 156: 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; 158: 8f ef ldi r24, 0xFF ; 255 15a: 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; } } 15c: 08 95 ret 0000015e <_ZN14HardwareSerial4peekEv>: { return ((unsigned int)(SERIAL_RX_BUFFER_SIZE + _rx_buffer_head - _rx_buffer_tail)) % SERIAL_RX_BUFFER_SIZE; } int HardwareSerial::peek(void) { 15e: fc 01 movw r30, r24 if (_rx_buffer_head == _rx_buffer_tail) { 160: 91 8d ldd r25, Z+25 ; 0x19 162: 82 8d ldd r24, Z+26 ; 0x1a 164: 98 17 cp r25, r24 166: 31 f0 breq .+12 ; 0x174 <_ZN14HardwareSerial4peekEv+0x16> return -1; } else { return _rx_buffer[_rx_buffer_tail]; 168: 82 8d ldd r24, Z+26 ; 0x1a 16a: e8 0f add r30, r24 16c: f1 1d adc r31, r1 16e: 85 8d ldd r24, Z+29 ; 0x1d 170: 90 e0 ldi r25, 0x00 ; 0 172: 08 95 ret } int HardwareSerial::peek(void) { if (_rx_buffer_head == _rx_buffer_tail) { return -1; 174: 8f ef ldi r24, 0xFF ; 255 176: 9f ef ldi r25, 0xFF ; 255 } else { return _rx_buffer[_rx_buffer_tail]; } } 178: 08 95 ret 0000017a <_ZN14HardwareSerial9availableEv>: // clear any received data _rx_buffer_head = _rx_buffer_tail; } int HardwareSerial::available(void) { 17a: fc 01 movw r30, r24 return ((unsigned int)(SERIAL_RX_BUFFER_SIZE + _rx_buffer_head - _rx_buffer_tail)) % SERIAL_RX_BUFFER_SIZE; 17c: 91 8d ldd r25, Z+25 ; 0x19 17e: 22 8d ldd r18, Z+26 ; 0x1a 180: 89 2f mov r24, r25 182: 90 e0 ldi r25, 0x00 ; 0 184: 80 5c subi r24, 0xC0 ; 192 186: 9f 4f sbci r25, 0xFF ; 255 188: 82 1b sub r24, r18 18a: 91 09 sbc r25, r1 } 18c: 8f 73 andi r24, 0x3F ; 63 18e: 99 27 eor r25, r25 190: 08 95 ret 00000192 <_Z17Serial0_availablev>: #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(); 192: 8c e1 ldi r24, 0x1C ; 28 194: 91 e0 ldi r25, 0x01 ; 1 196: 0e 94 bd 00 call 0x17a ; 0x17a <_ZN14HardwareSerial9availableEv> 19a: 21 e0 ldi r18, 0x01 ; 1 19c: 89 2b or r24, r25 19e: 09 f4 brne .+2 ; 0x1a2 <_Z17Serial0_availablev+0x10> 1a0: 20 e0 ldi r18, 0x00 ; 0 } 1a2: 82 2f mov r24, r18 1a4: 08 95 ret 000001a6 <_Z14serialEventRunv>: #endif void serialEventRun(void) { #if defined(HAVE_HWSERIAL0) if (Serial0_available && serialEvent && Serial0_available()) serialEvent(); 1a6: 80 e0 ldi r24, 0x00 ; 0 1a8: 90 e0 ldi r25, 0x00 ; 0 1aa: 89 2b or r24, r25 1ac: 29 f0 breq .+10 ; 0x1b8 <_Z14serialEventRunv+0x12> 1ae: 0e 94 c9 00 call 0x192 ; 0x192 <_Z17Serial0_availablev> 1b2: 81 11 cpse r24, r1 1b4: 0c 94 00 00 jmp 0 ; 0x0 <__vectors> if (Serial2_available && serialEvent2 && Serial2_available()) serialEvent2(); #endif #if defined(HAVE_HWSERIAL3) if (Serial3_available && serialEvent3 && Serial3_available()) serialEvent3(); #endif } 1b8: 08 95 ret 000001ba <_ZN14HardwareSerial17_tx_udr_empty_irqEv>: #endif // Actual interrupt handlers ////////////////////////////////////////////////////////////// void HardwareSerial::_tx_udr_empty_irq(void) { 1ba: 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]; 1bc: a4 8d ldd r26, Z+28 ; 0x1c 1be: a8 0f add r26, r24 1c0: b9 2f mov r27, r25 1c2: b1 1d adc r27, r1 1c4: a3 5a subi r26, 0xA3 ; 163 1c6: bf 4f sbci r27, 0xFF ; 255 1c8: 2c 91 ld r18, X _tx_buffer_tail = (_tx_buffer_tail + 1) % SERIAL_TX_BUFFER_SIZE; 1ca: 84 8d ldd r24, Z+28 ; 0x1c 1cc: 90 e0 ldi r25, 0x00 ; 0 1ce: 01 96 adiw r24, 0x01 ; 1 1d0: 8f 73 andi r24, 0x3F ; 63 1d2: 99 27 eor r25, r25 1d4: 84 8f std Z+28, r24 ; 0x1c *_udr = c; 1d6: a6 89 ldd r26, Z+22 ; 0x16 1d8: b7 89 ldd r27, Z+23 ; 0x17 1da: 2c 93 st X, r18 // location". This makes sure flush() won't return until the bytes // actually got written. Other r/w bits are preserved, and zeroes // written to the rest. #ifdef MPCM0 *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << MPCM0))) | (1 << TXC0); 1dc: a0 89 ldd r26, Z+16 ; 0x10 1de: b1 89 ldd r27, Z+17 ; 0x11 1e0: 8c 91 ld r24, X 1e2: 83 70 andi r24, 0x03 ; 3 1e4: 80 64 ori r24, 0x40 ; 64 1e6: 8c 93 st X, r24 #else *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << TXC0))); #endif if (_tx_buffer_head == _tx_buffer_tail) { 1e8: 93 8d ldd r25, Z+27 ; 0x1b 1ea: 84 8d ldd r24, Z+28 ; 0x1c 1ec: 98 13 cpse r25, r24 1ee: 06 c0 rjmp .+12 ; 0x1fc <_ZN14HardwareSerial17_tx_udr_empty_irqEv+0x42> // Buffer empty, so disable interrupts cbi(*_ucsrb, UDRIE0); 1f0: 02 88 ldd r0, Z+18 ; 0x12 1f2: f3 89 ldd r31, Z+19 ; 0x13 1f4: e0 2d mov r30, r0 1f6: 80 81 ld r24, Z 1f8: 8f 7d andi r24, 0xDF ; 223 1fa: 80 83 st Z, r24 } } 1fc: 08 95 ret 000001fe <_ZN14HardwareSerial5writeEh>: // 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) { 1fe: ef 92 push r14 200: ff 92 push r15 202: 0f 93 push r16 204: 1f 93 push r17 206: cf 93 push r28 208: df 93 push r29 20a: ec 01 movw r28, r24 _written = true; 20c: 81 e0 ldi r24, 0x01 ; 1 20e: 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)) { 210: 9b 8d ldd r25, Y+27 ; 0x1b 212: 8c 8d ldd r24, Y+28 ; 0x1c 214: 98 13 cpse r25, r24 216: 1a c0 rjmp .+52 ; 0x24c <_ZN14HardwareSerial5writeEh+0x4e> 218: e8 89 ldd r30, Y+16 ; 0x10 21a: f9 89 ldd r31, Y+17 ; 0x11 21c: 80 81 ld r24, Z 21e: 85 ff sbrs r24, 5 220: 15 c0 rjmp .+42 ; 0x24c <_ZN14HardwareSerial5writeEh+0x4e> // So writing UDR must happen first. // Writing UDR and clearing TC must be done atomically, otherwise // interrupts might delay the TXC clear so the byte written to UDR // is transmitted (setting TXC) before clearing TXC. Then TXC will // be cleared when no bytes are left, causing flush() to hang ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { 222: 9f b7 in r25, 0x3f ; 63 return 1; } static __inline__ uint8_t __iCliRetVal(void) { cli(); 224: f8 94 cli *_udr = c; 226: ee 89 ldd r30, Y+22 ; 0x16 228: ff 89 ldd r31, Y+23 ; 0x17 22a: 60 83 st Z, r22 #ifdef MPCM0 *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << MPCM0))) | (1 << TXC0); 22c: e8 89 ldd r30, Y+16 ; 0x10 22e: f9 89 ldd r31, Y+17 ; 0x11 230: 80 81 ld r24, Z 232: 83 70 andi r24, 0x03 ; 3 234: 80 64 ori r24, 0x40 ; 64 // make atomic to prevent execution of ISR between setting the // head pointer and setting the interrupt flag resulting in buffer // retransmission ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { _tx_buffer_head = i; sbi(*_ucsrb, UDRIE0); 236: 80 83 st Z, r24 (void)__s; } static __inline__ void __iRestore(const uint8_t *__s) { SREG = *__s; 238: 9f bf out 0x3f, r25 ; 63 } return 1; } 23a: 81 e0 ldi r24, 0x01 ; 1 23c: 90 e0 ldi r25, 0x00 ; 0 23e: df 91 pop r29 240: cf 91 pop r28 242: 1f 91 pop r17 244: 0f 91 pop r16 246: ff 90 pop r15 248: ef 90 pop r14 24a: 08 95 ret 24c: f6 2e mov r15, r22 *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << TXC0))); #endif } return 1; } tx_buffer_index_t i = (_tx_buffer_head + 1) % SERIAL_TX_BUFFER_SIZE; 24e: 0b 8d ldd r16, Y+27 ; 0x1b 250: 10 e0 ldi r17, 0x00 ; 0 252: 0f 5f subi r16, 0xFF ; 255 254: 1f 4f sbci r17, 0xFF ; 255 256: 0f 73 andi r16, 0x3F ; 63 258: 11 27 eor r17, r17 25a: 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) { 25c: 8c 8d ldd r24, Y+28 ; 0x1c 25e: 8e 11 cpse r24, r14 260: 0c c0 rjmp .+24 ; 0x27a <_ZN14HardwareSerial5writeEh+0x7c> if (bit_is_clear(SREG, SREG_I)) { 262: 0f b6 in r0, 0x3f ; 63 264: 07 fc sbrc r0, 7 266: fa cf rjmp .-12 ; 0x25c <_ZN14HardwareSerial5writeEh+0x5e> // 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)) 268: e8 89 ldd r30, Y+16 ; 0x10 26a: f9 89 ldd r31, Y+17 ; 0x11 26c: 80 81 ld r24, Z 26e: 85 ff sbrs r24, 5 270: f5 cf rjmp .-22 ; 0x25c <_ZN14HardwareSerial5writeEh+0x5e> _tx_udr_empty_irq(); 272: ce 01 movw r24, r28 274: 0e 94 dd 00 call 0x1ba ; 0x1ba <_ZN14HardwareSerial17_tx_udr_empty_irqEv> 278: f1 cf rjmp .-30 ; 0x25c <_ZN14HardwareSerial5writeEh+0x5e> } else { // nop, the interrupt handler will free up space for us } } _tx_buffer[_tx_buffer_head] = c; 27a: eb 8d ldd r30, Y+27 ; 0x1b 27c: ec 0f add r30, r28 27e: fd 2f mov r31, r29 280: f1 1d adc r31, r1 282: e3 5a subi r30, 0xA3 ; 163 284: ff 4f sbci r31, 0xFF ; 255 286: f0 82 st Z, r15 // make atomic to prevent execution of ISR between setting the // head pointer and setting the interrupt flag resulting in buffer // retransmission ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { 288: 9f b7 in r25, 0x3f ; 63 return 1; } static __inline__ uint8_t __iCliRetVal(void) { cli(); 28a: f8 94 cli _tx_buffer_head = i; 28c: 0b 8f std Y+27, r16 ; 0x1b sbi(*_ucsrb, UDRIE0); 28e: ea 89 ldd r30, Y+18 ; 0x12 290: fb 89 ldd r31, Y+19 ; 0x13 292: 80 81 ld r24, Z 294: 80 62 ori r24, 0x20 ; 32 296: cf cf rjmp .-98 ; 0x236 <_ZN14HardwareSerial5writeEh+0x38> 00000298 <_ZN14HardwareSerial5flushEv>: if (head >= tail) return SERIAL_TX_BUFFER_SIZE - 1 - head + tail; return tail - head - 1; } void HardwareSerial::flush() { 298: cf 93 push r28 29a: df 93 push r29 29c: 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) 29e: 88 8d ldd r24, Y+24 ; 0x18 2a0: 88 23 and r24, r24 2a2: b9 f0 breq .+46 ; 0x2d2 <_ZN14HardwareSerial5flushEv+0x3a> return; while (bit_is_set(*_ucsrb, UDRIE0) || bit_is_clear(*_ucsra, TXC0)) { 2a4: aa 89 ldd r26, Y+18 ; 0x12 2a6: bb 89 ldd r27, Y+19 ; 0x13 2a8: e8 89 ldd r30, Y+16 ; 0x10 2aa: f9 89 ldd r31, Y+17 ; 0x11 2ac: 8c 91 ld r24, X 2ae: 85 fd sbrc r24, 5 2b0: 03 c0 rjmp .+6 ; 0x2b8 <_ZN14HardwareSerial5flushEv+0x20> 2b2: 80 81 ld r24, Z 2b4: 86 fd sbrc r24, 6 2b6: 0d c0 rjmp .+26 ; 0x2d2 <_ZN14HardwareSerial5flushEv+0x3a> if (bit_is_clear(SREG, SREG_I) && bit_is_set(*_ucsrb, UDRIE0)) 2b8: 0f b6 in r0, 0x3f ; 63 2ba: 07 fc sbrc r0, 7 2bc: f7 cf rjmp .-18 ; 0x2ac <_ZN14HardwareSerial5flushEv+0x14> 2be: 8c 91 ld r24, X 2c0: 85 ff sbrs r24, 5 2c2: f2 cf rjmp .-28 ; 0x2a8 <_ZN14HardwareSerial5flushEv+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)) 2c4: 80 81 ld r24, Z 2c6: 85 ff sbrs r24, 5 2c8: ed cf rjmp .-38 ; 0x2a4 <_ZN14HardwareSerial5flushEv+0xc> _tx_udr_empty_irq(); 2ca: ce 01 movw r24, r28 2cc: 0e 94 dd 00 call 0x1ba ; 0x1ba <_ZN14HardwareSerial17_tx_udr_empty_irqEv> 2d0: e9 cf rjmp .-46 ; 0x2a4 <_ZN14HardwareSerial5flushEv+0xc> } // If we get here, nothing is queued anymore (DRIE is disabled) and // the hardware finished tranmission (TXC is set). } 2d2: df 91 pop r29 2d4: cf 91 pop r28 2d6: 08 95 ret 000002d8 <__vector_16>: #if defined(TIM0_OVF_vect) ISR(TIM0_OVF_vect) #else ISR(TIMER0_OVF_vect) #endif { 2d8: 1f 92 push r1 2da: 0f 92 push r0 2dc: 0f b6 in r0, 0x3f ; 63 2de: 0f 92 push r0 2e0: 11 24 eor r1, r1 2e2: 2f 93 push r18 2e4: 3f 93 push r19 2e6: 8f 93 push r24 2e8: 9f 93 push r25 2ea: af 93 push r26 2ec: 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; 2ee: 80 91 be 01 lds r24, 0x01BE ; 0x8001be <timer0_millis> 2f2: 90 91 bf 01 lds r25, 0x01BF ; 0x8001bf <timer0_millis+0x1> 2f6: a0 91 c0 01 lds r26, 0x01C0 ; 0x8001c0 <timer0_millis+0x2> 2fa: b0 91 c1 01 lds r27, 0x01C1 ; 0x8001c1 <timer0_millis+0x3> unsigned char f = timer0_fract; 2fe: 30 91 bd 01 lds r19, 0x01BD ; 0x8001bd <timer0_fract> m += MILLIS_INC; f += FRACT_INC; 302: 23 e0 ldi r18, 0x03 ; 3 304: 23 0f add r18, r19 if (f >= FRACT_MAX) { 306: 2d 37 cpi r18, 0x7D ; 125 308: 58 f5 brcc .+86 ; 0x360 <__vector_16+0x88> // 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; 30a: 01 96 adiw r24, 0x01 ; 1 30c: a1 1d adc r26, r1 30e: b1 1d adc r27, r1 if (f >= FRACT_MAX) { f -= FRACT_MAX; m += 1; } timer0_fract = f; 310: 20 93 bd 01 sts 0x01BD, r18 ; 0x8001bd <timer0_fract> timer0_millis = m; 314: 80 93 be 01 sts 0x01BE, r24 ; 0x8001be <timer0_millis> 318: 90 93 bf 01 sts 0x01BF, r25 ; 0x8001bf <timer0_millis+0x1> 31c: a0 93 c0 01 sts 0x01C0, r26 ; 0x8001c0 <timer0_millis+0x2> 320: b0 93 c1 01 sts 0x01C1, r27 ; 0x8001c1 <timer0_millis+0x3> timer0_overflow_count++; 324: 80 91 b9 01 lds r24, 0x01B9 ; 0x8001b9 <timer0_overflow_count> 328: 90 91 ba 01 lds r25, 0x01BA ; 0x8001ba <timer0_overflow_count+0x1> 32c: a0 91 bb 01 lds r26, 0x01BB ; 0x8001bb <timer0_overflow_count+0x2> 330: b0 91 bc 01 lds r27, 0x01BC ; 0x8001bc <timer0_overflow_count+0x3> 334: 01 96 adiw r24, 0x01 ; 1 336: a1 1d adc r26, r1 338: b1 1d adc r27, r1 33a: 80 93 b9 01 sts 0x01B9, r24 ; 0x8001b9 <timer0_overflow_count> 33e: 90 93 ba 01 sts 0x01BA, r25 ; 0x8001ba <timer0_overflow_count+0x1> 342: a0 93 bb 01 sts 0x01BB, r26 ; 0x8001bb <timer0_overflow_count+0x2> 346: b0 93 bc 01 sts 0x01BC, r27 ; 0x8001bc <timer0_overflow_count+0x3> } 34a: bf 91 pop r27 34c: af 91 pop r26 34e: 9f 91 pop r25 350: 8f 91 pop r24 352: 3f 91 pop r19 354: 2f 91 pop r18 356: 0f 90 pop r0 358: 0f be out 0x3f, r0 ; 63 35a: 0f 90 pop r0 35c: 1f 90 pop r1 35e: 18 95 reti unsigned char f = timer0_fract; m += MILLIS_INC; f += FRACT_INC; if (f >= FRACT_MAX) { f -= FRACT_MAX; 360: 26 e8 ldi r18, 0x86 ; 134 362: 23 0f add r18, r19 m += 1; 364: 02 96 adiw r24, 0x02 ; 2 366: a1 1d adc r26, r1 368: b1 1d adc r27, r1 36a: d2 cf rjmp .-92 ; 0x310 <__vector_16+0x38> 0000036c <__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 { 36c: 1f 92 push r1 36e: 0f 92 push r0 370: 0f b6 in r0, 0x3f ; 63 372: 0f 92 push r0 374: 11 24 eor r1, r1 376: 2f 93 push r18 378: 3f 93 push r19 37a: 4f 93 push r20 37c: 5f 93 push r21 37e: 6f 93 push r22 380: 7f 93 push r23 382: 8f 93 push r24 384: 9f 93 push r25 386: af 93 push r26 388: bf 93 push r27 38a: ef 93 push r30 38c: ff 93 push r31 Serial._tx_udr_empty_irq(); 38e: 8c e1 ldi r24, 0x1C ; 28 390: 91 e0 ldi r25, 0x01 ; 1 392: 0e 94 dd 00 call 0x1ba ; 0x1ba <_ZN14HardwareSerial17_tx_udr_empty_irqEv> } 396: ff 91 pop r31 398: ef 91 pop r30 39a: bf 91 pop r27 39c: af 91 pop r26 39e: 9f 91 pop r25 3a0: 8f 91 pop r24 3a2: 7f 91 pop r23 3a4: 6f 91 pop r22 3a6: 5f 91 pop r21 3a8: 4f 91 pop r20 3aa: 3f 91 pop r19 3ac: 2f 91 pop r18 3ae: 0f 90 pop r0 3b0: 0f be out 0x3f, r0 ; 63 3b2: 0f 90 pop r0 3b4: 1f 90 pop r1 3b6: 18 95 reti 000003b8 <__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 { 3b8: 1f 92 push r1 3ba: 0f 92 push r0 3bc: 0f b6 in r0, 0x3f ; 63 3be: 0f 92 push r0 3c0: 11 24 eor r1, r1 3c2: 2f 93 push r18 3c4: 8f 93 push r24 3c6: 9f 93 push r25 3c8: ef 93 push r30 3ca: ff 93 push r31 // Actual interrupt handlers ////////////////////////////////////////////////////////////// void HardwareSerial::_rx_complete_irq(void) { if (bit_is_clear(*_ucsra, UPE0)) { 3cc: e0 91 2c 01 lds r30, 0x012C ; 0x80012c <__data_end+0x10> 3d0: f0 91 2d 01 lds r31, 0x012D ; 0x80012d <__data_end+0x11> 3d4: 80 81 ld r24, Z 3d6: e0 91 32 01 lds r30, 0x0132 ; 0x800132 <__data_end+0x16> 3da: f0 91 33 01 lds r31, 0x0133 ; 0x800133 <__data_end+0x17> 3de: 82 fd sbrc r24, 2 3e0: 1b c0 rjmp .+54 ; 0x418 <__LOCK_REGION_LENGTH__+0x18> // No Parity error, read byte and store it in the buffer if there is // room unsigned char c = *_udr; 3e2: 90 81 ld r25, Z rx_buffer_index_t i = (unsigned int)(_rx_buffer_head + 1) % SERIAL_RX_BUFFER_SIZE; 3e4: 80 91 35 01 lds r24, 0x0135 ; 0x800135 <__data_end+0x19> 3e8: 8f 5f subi r24, 0xFF ; 255 3ea: 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) { 3ec: 20 91 36 01 lds r18, 0x0136 ; 0x800136 <__data_end+0x1a> 3f0: 82 17 cp r24, r18 3f2: 41 f0 breq .+16 ; 0x404 <__LOCK_REGION_LENGTH__+0x4> _rx_buffer[_rx_buffer_head] = c; 3f4: e0 91 35 01 lds r30, 0x0135 ; 0x800135 <__data_end+0x19> 3f8: f0 e0 ldi r31, 0x00 ; 0 3fa: e4 5e subi r30, 0xE4 ; 228 3fc: fe 4f sbci r31, 0xFE ; 254 3fe: 95 8f std Z+29, r25 ; 0x1d _rx_buffer_head = i; 400: 80 93 35 01 sts 0x0135, r24 ; 0x800135 <__data_end+0x19> Serial._rx_complete_irq(); } 404: ff 91 pop r31 406: ef 91 pop r30 408: 9f 91 pop r25 40a: 8f 91 pop r24 40c: 2f 91 pop r18 40e: 0f 90 pop r0 410: 0f be out 0x3f, r0 ; 63 412: 0f 90 pop r0 414: 1f 90 pop r1 416: 18 95 reti } } else { // Parity error, read byte but discard it *_udr; 418: 80 81 ld r24, Z 41a: f4 cf rjmp .-24 ; 0x404 <__LOCK_REGION_LENGTH__+0x4> 0000041c <main>: void init() { // this needs to be called before setup() or some functions won't // work there sei(); 41c: 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); 41e: 84 b5 in r24, 0x24 ; 36 420: 82 60 ori r24, 0x02 ; 2 422: 84 bd out 0x24, r24 ; 36 sbi(TCCR0A, WGM00); 424: 84 b5 in r24, 0x24 ; 36 426: 81 60 ori r24, 0x01 ; 1 428: 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); 42a: 85 b5 in r24, 0x25 ; 37 42c: 82 60 ori r24, 0x02 ; 2 42e: 85 bd out 0x25, r24 ; 37 sbi(TCCR0B, CS00); 430: 85 b5 in r24, 0x25 ; 37 432: 81 60 ori r24, 0x01 ; 1 434: 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); 436: 80 91 6e 00 lds r24, 0x006E ; 0x80006e <__DATA_REGION_ORIGIN__+0xe> 43a: 81 60 ori r24, 0x01 ; 1 43c: 80 93 6e 00 sts 0x006E, r24 ; 0x80006e <__DATA_REGION_ORIGIN__+0xe> // 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; 440: 10 92 81 00 sts 0x0081, r1 ; 0x800081 <__DATA_REGION_ORIGIN__+0x21> // set timer 1 prescale factor to 64 sbi(TCCR1B, CS11); 444: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__DATA_REGION_ORIGIN__+0x21> 448: 82 60 ori r24, 0x02 ; 2 44a: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__DATA_REGION_ORIGIN__+0x21> #if F_CPU >= 8000000L sbi(TCCR1B, CS10); 44e: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__DATA_REGION_ORIGIN__+0x21> 452: 81 60 ori r24, 0x01 ; 1 454: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__DATA_REGION_ORIGIN__+0x21> sbi(TCCR1, CS10); #endif #endif // put timer 1 in 8-bit phase correct pwm mode #if defined(TCCR1A) && defined(WGM10) sbi(TCCR1A, WGM10); 458: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__DATA_REGION_ORIGIN__+0x20> 45c: 81 60 ori r24, 0x01 ; 1 45e: 80 93 80 00 sts 0x0080, r24 ; 0x800080 <__DATA_REGION_ORIGIN__+0x20> // set timer 2 prescale factor to 64 #if defined(TCCR2) && defined(CS22) sbi(TCCR2, CS22); #elif defined(TCCR2B) && defined(CS22) sbi(TCCR2B, CS22); 462: 80 91 b1 00 lds r24, 0x00B1 ; 0x8000b1 <__DATA_REGION_ORIGIN__+0x51> 466: 84 60 ori r24, 0x04 ; 4 468: 80 93 b1 00 sts 0x00B1, r24 ; 0x8000b1 <__DATA_REGION_ORIGIN__+0x51> // 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); 46c: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__DATA_REGION_ORIGIN__+0x50> 470: 81 60 ori r24, 0x01 ; 1 472: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0 <__DATA_REGION_ORIGIN__+0x50> #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); 476: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a> 47a: 84 60 ori r24, 0x04 ; 4 47c: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a> sbi(ADCSRA, ADPS1); 480: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a> 484: 82 60 ori r24, 0x02 ; 2 486: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a> sbi(ADCSRA, ADPS0); 48a: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a> 48e: 81 60 ori r24, 0x01 ; 1 490: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a> cbi(ADCSRA, ADPS2); cbi(ADCSRA, ADPS1); sbi(ADCSRA, ADPS0); #endif // enable a2d conversions sbi(ADCSRA, ADEN); 494: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a> 498: 80 68 ori r24, 0x80 ; 128 49a: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a> // 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; 49e: 10 92 c1 00 sts 0x00C1, r1 ; 0x8000c1 <__DATA_REGION_ORIGIN__+0x61> 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; 4a2: e0 91 2c 01 lds r30, 0x012C ; 0x80012c <__data_end+0x10> 4a6: f0 91 2d 01 lds r31, 0x012D ; 0x80012d <__data_end+0x11> 4aa: 82 e0 ldi r24, 0x02 ; 2 4ac: 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; 4ae: e0 91 28 01 lds r30, 0x0128 ; 0x800128 <__data_end+0xc> 4b2: f0 91 29 01 lds r31, 0x0129 ; 0x800129 <__data_end+0xd> 4b6: 10 82 st Z, r1 *_ubrrl = baud_setting; 4b8: e0 91 2a 01 lds r30, 0x012A ; 0x80012a <__data_end+0xe> 4bc: f0 91 2b 01 lds r31, 0x012B ; 0x80012b <__data_end+0xf> 4c0: 8f ec ldi r24, 0xCF ; 207 4c2: 80 83 st Z, r24 _written = false; 4c4: 10 92 34 01 sts 0x0134, r1 ; 0x800134 <__data_end+0x18> //set the data bits, parity, and stop bits #if defined(__AVR_ATmega8__) config |= 0x80; // select UCSRC register (shared with UBRRH) #endif *_ucsrc = config; 4c8: e0 91 30 01 lds r30, 0x0130 ; 0x800130 <__data_end+0x14> 4cc: f0 91 31 01 lds r31, 0x0131 ; 0x800131 <__data_end+0x15> 4d0: 86 e0 ldi r24, 0x06 ; 6 4d2: 80 83 st Z, r24 sbi(*_ucsrb, RXEN0); 4d4: e0 91 2e 01 lds r30, 0x012E ; 0x80012e <__data_end+0x12> 4d8: f0 91 2f 01 lds r31, 0x012F ; 0x80012f <__data_end+0x13> 4dc: 80 81 ld r24, Z 4de: 80 61 ori r24, 0x10 ; 16 4e0: 80 83 st Z, r24 sbi(*_ucsrb, TXEN0); 4e2: e0 91 2e 01 lds r30, 0x012E ; 0x80012e <__data_end+0x12> 4e6: f0 91 2f 01 lds r31, 0x012F ; 0x80012f <__data_end+0x13> 4ea: 80 81 ld r24, Z 4ec: 88 60 ori r24, 0x08 ; 8 4ee: 80 83 st Z, r24 sbi(*_ucsrb, RXCIE0); 4f0: e0 91 2e 01 lds r30, 0x012E ; 0x80012e <__data_end+0x12> 4f4: f0 91 2f 01 lds r31, 0x012F ; 0x80012f <__data_end+0x13> 4f8: 80 81 ld r24, Z 4fa: 80 68 ori r24, 0x80 ; 128 4fc: 80 83 st Z, r24 cbi(*_ucsrb, UDRIE0); 4fe: e0 91 2e 01 lds r30, 0x012E ; 0x80012e <__data_end+0x12> 502: f0 91 2f 01 lds r31, 0x012F ; 0x80012f <__data_end+0x13> 506: 80 81 ld r24, Z 508: 8f 7d andi r24, 0xDF ; 223 50a: 80 83 st Z, r24 void clearWriteError() { setWriteError(0); } virtual size_t write(uint8_t) = 0; size_t write(const char *str) { if (str == NULL) return 0; return write((const uint8_t *)str, strlen(str)); 50c: 40 e0 ldi r20, 0x00 ; 0 50e: 51 e0 ldi r21, 0x01 ; 1 510: fa 01 movw r30, r20 512: 01 90 ld r0, Z+ 514: 00 20 and r0, r0 516: e9 f7 brne .-6 ; 0x512 <main+0xf6> 518: af 01 movw r20, r30 51a: 41 50 subi r20, 0x01 ; 1 51c: 51 40 sbci r21, 0x01 ; 1 51e: 60 e0 ldi r22, 0x00 ; 0 520: 71 e0 ldi r23, 0x01 ; 1 522: 8c e1 ldi r24, 0x1C ; 28 524: 91 e0 ldi r25, 0x01 ; 1 526: 0e 94 5f 00 call 0xbe ; 0xbe <_ZN5Print5writeEPKhj> 52a: 42 e0 ldi r20, 0x02 ; 2 52c: 50 e0 ldi r21, 0x00 ; 0 52e: 68 e1 ldi r22, 0x18 ; 24 530: 71 e0 ldi r23, 0x01 ; 1 532: 8c e1 ldi r24, 0x1C ; 28 534: 91 e0 ldi r25, 0x01 ; 1 536: 0e 94 5f 00 call 0xbe ; 0xbe <_ZN5Print5writeEPKhj> #endif void serialEventRun(void) { #if defined(HAVE_HWSERIAL0) if (Serial0_available && serialEvent && Serial0_available()) serialEvent(); 53a: c0 e0 ldi r28, 0x00 ; 0 53c: d0 e0 ldi r29, 0x00 ; 0 53e: 20 97 sbiw r28, 0x00 ; 0 540: f1 f3 breq .-4 ; 0x53e <main+0x122> 542: 0e 94 c9 00 call 0x192 ; 0x192 <_Z17Serial0_availablev> 546: 88 23 and r24, r24 548: d1 f3 breq .-12 ; 0x53e <main+0x122> 54a: 0e 94 00 00 call 0 ; 0x0 <__vectors> 54e: f7 cf rjmp .-18 ; 0x53e <main+0x122> 00000550 <_GLOBAL__sub_I___vector_18>: 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) {} 550: ec e1 ldi r30, 0x1C ; 28 552: f1 e0 ldi r31, 0x01 ; 1 554: 13 82 std Z+3, r1 ; 0x03 556: 12 82 std Z+2, r1 ; 0x02 public: virtual int available() = 0; virtual int read() = 0; virtual int peek() = 0; Stream() {_timeout=1000;} 558: 88 ee ldi r24, 0xE8 ; 232 55a: 93 e0 ldi r25, 0x03 ; 3 55c: a0 e0 ldi r26, 0x00 ; 0 55e: b0 e0 ldi r27, 0x00 ; 0 560: 84 83 std Z+4, r24 ; 0x04 562: 95 83 std Z+5, r25 ; 0x05 564: a6 83 std Z+6, r26 ; 0x06 566: b7 83 std Z+7, r27 ; 0x07 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) 568: 8a e0 ldi r24, 0x0A ; 10 56a: 91 e0 ldi r25, 0x01 ; 1 56c: 91 83 std Z+1, r25 ; 0x01 56e: 80 83 st Z, r24 570: 85 ec ldi r24, 0xC5 ; 197 572: 90 e0 ldi r25, 0x00 ; 0 574: 95 87 std Z+13, r25 ; 0x0d 576: 84 87 std Z+12, r24 ; 0x0c 578: 84 ec ldi r24, 0xC4 ; 196 57a: 90 e0 ldi r25, 0x00 ; 0 57c: 97 87 std Z+15, r25 ; 0x0f 57e: 86 87 std Z+14, r24 ; 0x0e 580: 80 ec ldi r24, 0xC0 ; 192 582: 90 e0 ldi r25, 0x00 ; 0 584: 91 8b std Z+17, r25 ; 0x11 586: 80 8b std Z+16, r24 ; 0x10 588: 81 ec ldi r24, 0xC1 ; 193 58a: 90 e0 ldi r25, 0x00 ; 0 58c: 93 8b std Z+19, r25 ; 0x13 58e: 82 8b std Z+18, r24 ; 0x12 590: 82 ec ldi r24, 0xC2 ; 194 592: 90 e0 ldi r25, 0x00 ; 0 594: 95 8b std Z+21, r25 ; 0x15 596: 84 8b std Z+20, r24 ; 0x14 598: 86 ec ldi r24, 0xC6 ; 198 59a: 90 e0 ldi r25, 0x00 ; 0 59c: 97 8b std Z+23, r25 ; 0x17 59e: 86 8b std Z+22, r24 ; 0x16 5a0: 11 8e std Z+25, r1 ; 0x19 5a2: 12 8e std Z+26, r1 ; 0x1a 5a4: 13 8e std Z+27, r1 ; 0x1b 5a6: 14 8e std Z+28, r1 ; 0x1c // 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(); } 5a8: 08 95 ret 000005aa <__tablejump2__>: 5aa: ee 0f add r30, r30 5ac: ff 1f adc r31, r31 5ae: 05 90 lpm r0, Z+ 5b0: f4 91 lpm r31, Z 5b2: e0 2d mov r30, r0 5b4: 09 94 ijmp 000005b6 <_exit>: 5b6: f8 94 cli 000005b8 <__stop_program>: 5b8: ff cf rjmp .-2 ; 0x5b8 <__stop_program>А то как догадываться, что именно Вы подразумеваете под словом "кракозябры".
уже бы давно развернул portable версию в новую папку, добавил бы туда папку portable и пример попробовал
nik182
7c: ea eb ldi r30, 0xBA ; 186
Спасибо
с ноликами из hex 48656C6C6F
без ноликов из нех 48656C6C6F
Да. Надо действительно учить снова....
Может не надо учить? Может сначала нолики перед числами поставить и проверить?
Учить как раз надо.
Выяснилось, что число должно быть не просто восмеричным, но обязательно трехзначным внезависимости от того, будет там ведущий ноль или нет. Что, впрочем, логично: строка \12345 понимается как char(oct123),'4','5', а строка \012345 - как строка char(oct12),'3','4','5'.
Учить как раз надо.
Выяснилось, что число должно быть не просто восмеричным, но обязательно трехзначным...
Не обязательно. Даже однозначным, если следующая не символьная восьмеричная цифра.
"Восьмеричная escape-последовательность — это обратная косая черта, за которой следует последовательность из одной до трех восьмеричных цифр. Восьмеричная escape-последовательность завершается на первом символе, который не является восьмеричной цифрой, если он встречается раньше, чем третья цифра. Наибольшее возможное восьмеричное значение —
\377."Вот такая вот фигня: что ни напишешь - все равно откомпилируется. Хотя и совсем не то, что хотел. К вопросу, почему я не люблю Си.