telect - если серьезно, твоя логика бы работала, если бы тут сидела куча голодных безработных программистов, готовых ухватится за любой заказ. Однако в реальности ситуация другая - заказов на рынке больше, чем желающих их выполнять. Так что у меня есть возможность выбирать и назначать свою цену.
Назначенная мной вилка - 5-10 штук - абсолютно в рынке. я даже думаю что многие коллеги попеняют мне, что я демпингую. Так что твои 1000р - ничего кроме смеха не вызывают. Нет денег - иди мимо.
<Однако в реальности ситуация другая - заказов на рынке больше, чем желающих их выполнять. Так что у меня есть возможность выбирать и назначать свою цену.
Ну тут просто кто-то найти деньги не может на канаву, вот я и написал. Ну если у вас всё так хорошо, то супер. Я ж не знал. Тут только дальнейшего процветания пожелать остается
Обесценивать работу в той сфере, в которой мало что понимаешь - обычное дело. Забавно было читать как про 1000р (с утра подняло настроение), так и про цену устройства ПРОМЫШЛЕННОЙ РАЗРАБОТКИ.
1м3 копания траншеи вручную на самом легком грунте (а таких, как известно, не бывает) стоит от 500р. При этом человек, который будет выполнять эту работу должен знать только что такое лопата.
Для программирования микроконтроллера исполнитель должен знать си++, структуру МК, схемотехнику, английский язык в достаточном для чтения даташитов объеме. Так что 1000р для такого человека - это, как было сказано выше, программа на уровне "блинк без дэлей". Делать что-то большее за эти деньги - это просто неуважение к себе.
Бывают случаи, когда самому интересно или есть практически готовые (свои) наработки. Но это - частные случаи.
Гы - это из реалии микроконтролеров. К яве и питону это никак не относится.
Какие такие реалии?
Листинг был на асме, при распечатывании результата после трансляции.
Ну да, можно и сейчас получить из elf-а, только кому он нафиг нужен. И разве это имелось ввиду?
Листинг был на асме, при распечатывании результата после трансляции.
Ну да, можно и сейчас получить из elf-а, только кому он нафиг нужен. И разве это имелось ввиду?
Он не "был", он "есть". И не только "на асме", си-компилятор тоже вполне нормально генерит листинги. И весьма полезен. Но для практиков, а не для теоретиков.
И из elf-a - сильно сомневаюсь что его можно получить. Из elf-а - только дизасм. Путаете "листинг" с "дизассемблером".
Листинг был на асме, при распечатывании результата после трансляции.
Ну да, можно и сейчас получить из elf-а, только кому он нафиг нужен. И разве это имелось ввиду?
Он не "был", он "есть". И не только "на асме", си-компилятор тоже вполне нормально генерит листинги. И весьма полезен. Но для практиков, а не для теоретиков.
И из elf-a - сильно сомневаюсь что его можно получить. Из elf-а - только дизасм. Путаете "листинг" с "дизассемблером".
В ардуинке - можно. Компилятор сохраняет в эльфе номера строк исходника.
В ардуинке - можно. Компилятор сохраняет в эльфе номера строк исходника.
"Номера строк исходника" - это хорошо. Но эта функция - для пошаговой отладки. Для привязки строк исходника к результирующему коду отладчиком. При имеющемся в наличии оригинальном файле исходника.
Если в наличии исходника нет, то сами номера строк (без их содержимого) - малоинформативны.
Или в ардуине в elf и содержимое строк исходника может сохраняться? Но ведь в обсуждаемом случае (когда автор не хочет отдавать исходник), а значит - автор кода позаботится о том, чтобы этих строк в .elf не было. Так что: из .elf только дизасм.
telect - если серьезно, твоя логика бы работала, если бы тут сидела куча голодных безработных программистов, готовых ухватится за любой заказ. Однако в реальности ситуация другая - заказов на рынке больше, чем желающих их выполнять. Так что у меня есть возможность выбирать и назначать свою цену.
Назначенная мной вилка - 5-10 штук - абсолютно в рынке. я даже думаю что многие коллеги попеняют мне, что я демпингую. Так что твои 1000р - ничего кроме смеха не вызывают. Нет денег - иди мимо.
Да мне канава не нужна и не я на деньги жалуюсь, так что не передергивай.
Хотел еще продолжить срач, но стер. Лениво уже стало отвечать
Ну тут просто кто-то найти деньги не может на канаву, вот я и написал. Ну если у вас всё так хорошо, то супер. Я ж не знал. Тут только дальнейшего процветания пожелать остается
Готовый пинжак тоже 2000р стоит, а попробуй заказать сшить по фигуре. За 1000 точно не получится.
у нас только работа - 10тыр. )))
А что, до пятницы не продержишься? Жаль!
Обесценивать работу в той сфере, в которой мало что понимаешь - обычное дело. Забавно было читать как про 1000р (с утра подняло настроение), так и про цену устройства ПРОМЫШЛЕННОЙ РАЗРАБОТКИ.
Нафига ? Оплатите себе курсы трейдинга и гребите миллионы лопатой на акциях )
1м3 копания траншеи вручную на самом легком грунте (а таких, как известно, не бывает) стоит от 500р. При этом человек, который будет выполнять эту работу должен знать только что такое лопата.
Для программирования микроконтроллера исполнитель должен знать си++, структуру МК, схемотехнику, английский язык в достаточном для чтения даташитов объеме. Так что 1000р для такого человека - это, как было сказано выше, программа на уровне "блинк без дэлей". Делать что-то большее за эти деньги - это просто неуважение к себе.
Бывают случаи, когда самому интересно или есть практически готовые (свои) наработки. Но это - частные случаи.
А с чего наработки должны снижать стоимость работы ? Такие "частные случаи" - скорее теория. Может быть продажа готового кода без листинга.
А с чего наработки должны снижать стоимость работы ?
Согласен. Но можно снизить предоставляя только машинный код. Только, типа, прошивка. А дальше гребись в ассемблере. Забавно...
Вообще, такие слова как листинг - это что то явно из прошлого.)
Вообще, такие слова как листинг - это что то явно из прошлого.)
Гы - это из реалии микроконтролеров. К яве и питону это никак не относится.
В бейсике была команда LIST, по-моему. Так что к языкам уровнем повыше асма тоже можно применить понятие "листинг", полагаю.
Гы - это из реалии микроконтролеров. К яве и питону это никак не относится.
Какие такие реалии?
Листинг был на асме, при распечатывании результата после трансляции.
Ну да, можно и сейчас получить из elf-а, только кому он нафиг нужен. И разве это имелось ввиду?
Это просто команда. В данном случае, команда "смотреть исходный текст".
https://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D1%81%D1%82%D0%B8%D0%BD%D0%B3#:~:text=%D0%9B%D0%B8%D1%81%D1%82%D0%B8%D0%BD%D0%B3%20(%D1%86%D0%B5%D0%BD%D0%BD%D1%8B%D0%B5%20%D0%B1%D1%83%D0%BC%D0%B0%D0%B3%D0%B8)%20%E2%80%94%20%D0%B2%D0%BD%D0%B5%D1%81%D0%B5%D0%BD%D0%B8%D0%B5,%D0%BA%D0%BE%D0%BC%D0%BF%D1%8C%D1%8E%D1%82%D0%B5%D1%80%D0%BD%D0%BE%D0%B9%20%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D1%8B%20%D0%B8%D0%BB%D0%B8%20%D0%B5%D1%91%20%D1%87%D0%B0%D1%81%D1%82%D0%B8.
это то что говорит википедия
Вот именно: "бумажная распечатка текста компьютерной программы или её части."
Ну да, можно и сейчас получить из elf-а, только кому он нафиг нужен. И разве это имелось ввиду?
Он не "был", он "есть". И не только "на асме", си-компилятор тоже вполне нормально генерит листинги. И весьма полезен. Но для практиков, а не для теоретиков.
И из elf-a - сильно сомневаюсь что его можно получить. Из elf-а - только дизасм. Путаете "листинг" с "дизассемблером".
Ну да, можно и сейчас получить из elf-а, только кому он нафиг нужен. И разве это имелось ввиду?
Он не "был", он "есть". И не только "на асме", си-компилятор тоже вполне нормально генерит листинги. И весьма полезен. Но для практиков, а не для теоретиков.
И из elf-a - сильно сомневаюсь что его можно получить. Из elf-а - только дизасм. Путаете "листинг" с "дизассемблером".
В ардуинке - можно. Компилятор сохраняет в эльфе номера строк исходника.
Вот такая команда:
1
/home/wlad/ArduinoIDE/hardware/tools/avr/bin/avr-objdump -S Blink.ino.elf >> 1.txt
Тут путь для линукса, для винды иначе.
и вот такой файл получается для штатного Блинка из примеров:
001
Blink.ino.elf: file format elf32-avr
002
003
004
Disassembly of section .text:
005
006
00000000 <__vectors>:
007
0: 0c 94 5c 00 jmp 0xb8 ; 0xb8 <__ctors_end>
008
4: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
009
8: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
010
c: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
011
10: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
012
14: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
013
18: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
014
1c: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
015
20: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
016
24: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
017
28: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
018
2c: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
019
30: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
020
34: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
021
38: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
022
3c: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
023
40: 0c 94 17 01 jmp 0x22e ; 0x22e <__vector_16>
024
44: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
025
48: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
026
4c: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
027
50: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
028
54: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
029
58: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
030
5c: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
031
60: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
032
64: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt>
033
034
00000068 <__trampolines_end>:
035
68: 00 00 nop
036
6a: 00 08 sbc r0, r0
037
6c: 00 02 muls r16, r16
038
6e: 01 00 .word 0x0001 ; ????
039
70: 00 03 mulsu r16, r16
040
72: 04 07 cpc r16, r20
041
...
042
043
0000007c <port_to_output_PGM>:
044
7c: 00 00 00 00 25 00 28 00 2b 00 ....%.(.+.
045
046
00000086 <port_to_mode_PGM>:
047
86: 00 00 00 00 24 00 27 00 2a 00 ....$.'.*.
048
049
00000090 <digital_pin_to_port_PGM>:
050
90: 04 04 04 04 04 04 04 04 02 02 02 02 02 02 03 03 ................
051
a0: 03 03 03 03 ....
052
053
000000a4 <digital_pin_to_bit_mask_PGM>:
054
a4: 01 02 04 08 10 20 40 80 01 02 04 08 10 20 01 02 ..... @...... ..
055
b4: 04 08 10 20 ...
056
057
000000b8 <__ctors_end>:
058
b8: 11 24 eor r1, r1
059
ba: 1f be
out
0x3f, r1 ; 63
060
bc: cf ef ldi r28, 0xFF ; 255
061
be: d8 e0 ldi r29, 0x08 ; 8
062
c0: de bf
out
0x3e, r29 ; 62
063
c2: cd bf
out
0x3d, r28 ; 61
064
065
000000c4 <__do_clear_bss>:
066
c4: 21 e0 ldi r18, 0x01 ; 1
067
c6: a0 e0 ldi r26, 0x00 ; 0
068
c8: b1 e0 ldi r27, 0x01 ; 1
069
ca: 01 c0 rjmp .+2 ; 0xce <.do_clear_bss_start>
070
071
000000cc <.do_clear_bss_loop>:
072
cc: 1d 92 st X+, r1
073
074
000000ce <.do_clear_bss_start>:
075
ce: a9 30 cpi r26, 0x09 ; 9
076
d0: b2 07 cpc r27, r18
077
d2: e1 f7 brne .-8 ; 0xcc <.do_clear_bss_loop>
078
d4: 0e 94 61 01 call 0x2c2 ; 0x2c2 <main>
079
d8: 0c 94 d2 01 jmp 0x3a4 ; 0x3a4 <_exit>
080
081
000000dc <__bad_interrupt>:
082
dc: 0c 94 00 00 jmp 0 ; 0x0 <__vectors>
083
084
000000e0 <digitalWrite>:
085
}
086
}
087
088
void
digitalWrite(uint8_t pin, uint8_t val)
089
{
090
uint8_t timer = digitalPinToTimer(pin);
091
e0: 90 e0 ldi r25, 0x00 ; 0
092
e2: fc 01 movw r30, r24
093
e4: e8 59 subi r30, 0x98 ; 152
094
e6: ff 4f sbci r31, 0xFF ; 255
095
e8: 24 91 lpm r18, Z
096
uint8_t bit = digitalPinToBitMask(pin);
097
ea: fc 01 movw r30, r24
098
ec: ec 55 subi r30, 0x5C ; 92
099
ee: ff 4f sbci r31, 0xFF ; 255
100
f0: 34 91 lpm r19, Z
101
uint8_t port = digitalPinToPort(pin);
102
f2: fc 01 movw r30, r24
103
f4: e0 57 subi r30, 0x70 ; 112
104
f6: ff 4f sbci r31, 0xFF ; 255
105
f8: e4 91 lpm r30, Z
106
volatile uint8_t *
out
;
107
108
if
(port == NOT_A_PIN)
return
;
109
fa: ee 23 and r30, r30
110
fc: c9 f0 breq .+50 ; 0x130 <digitalWrite+0x50>
111
112
// If the pin that support PWM output, we need to turn it off
113
// before doing a digital write.
114
if
(timer != NOT_ON_TIMER) turnOffPWM(timer);
115
fe: 22 23 and r18, r18
116
100: 39 f0 breq .+14 ; 0x110 <digitalWrite+0x30>
117
//
118
//static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline));
119
//static inline void turnOffPWM(uint8_t timer)
120
static
void
turnOffPWM(uint8_t timer)
121
{
122
switch
(timer)
123
102: 23 30 cpi r18, 0x03 ; 3
124
104: 01 f1 breq .+64 ; 0x146 <digitalWrite+0x66>
125
106: a8 f4 brcc .+42 ; 0x132 <digitalWrite+0x52>
126
108: 21 30 cpi r18, 0x01 ; 1
127
10a: 19 f1 breq .+70 ; 0x152 <digitalWrite+0x72>
128
10c: 22 30 cpi r18, 0x02 ; 2
129
10e: 29 f1 breq .+74 ; 0x15a <digitalWrite+0x7a>
130
131
// If the pin that support PWM output, we need to turn it off
132
// before doing a digital write.
133
if
(timer != NOT_ON_TIMER) turnOffPWM(timer);
134
135
out
= portOutputRegister(port);
136
110: f0 e0 ldi r31, 0x00 ; 0
137
112: ee 0f add r30, r30
138
114: ff 1f adc r31, r31
139
116: e4 58 subi r30, 0x84 ; 132
140
118: ff 4f sbci r31, 0xFF ; 255
141
11a: a5 91 lpm r26, Z+
142
11c: b4 91 lpm r27, Z
143
144
uint8_t oldSREG = SREG;
145
11e: 8f b7
in
r24, 0x3f ; 63
146
cli();
147
120: f8 94 cli
148
149
if
(val == LOW) {
150
*
out
&= ~bit;
151
122: ec 91 ld r30, X
152
out
= portOutputRegister(port);
153
154
uint8_t oldSREG = SREG;
155
cli();
156
157
if
(val == LOW) {
158
124: 61 11 cpse r22, r1
159
126: 26 c0 rjmp .+76 ; 0x174 <digitalWrite+0x94>
160
*
out
&= ~bit;
161
128: 30 95 com r19
162
12a: 3e 23 and r19, r30
163
}
else
{
164
*
out
|= bit;
165
12c: 3c 93 st X, r19
166
}
167
168
SREG = oldSREG;
169
12e: 8f bf
out
0x3f, r24 ; 63
170
}
171
130: 08 95 ret
172
//
173
//static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline));
174
//static inline void turnOffPWM(uint8_t timer)
175
static
void
turnOffPWM(uint8_t timer)
176
{
177
switch
(timer)
178
132: 27 30 cpi r18, 0x07 ; 7
179
134: a9 f0 breq .+42 ; 0x160 <digitalWrite+0x80>
180
136: 28 30 cpi r18, 0x08 ; 8
181
138: c9 f0 breq .+50 ; 0x16c <digitalWrite+0x8c>
182
13a: 24 30 cpi r18, 0x04 ; 4
183
13c: 49 f7 brne .-46 ; 0x110 <digitalWrite+0x30>
184
{
185
#if defined(TCCR1A) && defined(COM1A1)
186
case
TIMER1A: cbi(TCCR1A, COM1A1);
break
;
187
#endif
188
#if defined(TCCR1A) && defined(COM1B1)
189
case
TIMER1B: cbi(TCCR1A, COM1B1);
break
;
190
13e: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__DATA_REGION_ORIGIN__+0x20>
191
142: 8f 7d andi r24, 0xDF ; 223
192
144: 03 c0 rjmp .+6 ; 0x14c <digitalWrite+0x6c>
193
static
void
turnOffPWM(uint8_t timer)
194
{
195
switch
(timer)
196
{
197
#if defined(TCCR1A) && defined(COM1A1)
198
case
TIMER1A: cbi(TCCR1A, COM1A1);
break
;
199
146: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__DATA_REGION_ORIGIN__+0x20>
200
14a: 8f 77 andi r24, 0x7F ; 127
201
#endif
202
#if defined(TCCR1A) && defined(COM1B1)
203
case
TIMER1B: cbi(TCCR1A, COM1B1);
break
;
204
14c: 80 93 80 00 sts 0x0080, r24 ; 0x800080 <__DATA_REGION_ORIGIN__+0x20>
205
150: df cf rjmp .-66 ; 0x110 <digitalWrite+0x30>
206
#if defined(TCCR2) && defined(COM21)
207
case
TIMER2: cbi(TCCR2, COM21);
break
;
208
#endif
209
210
#if defined(TCCR0A) && defined(COM0A1)
211
case
TIMER0A: cbi(TCCR0A, COM0A1);
break
;
212
152: 84 b5
in
r24, 0x24 ; 36
213
154: 8f 77 andi r24, 0x7F ; 127
214
#endif
215
216
#if defined(TCCR0A) && defined(COM0B1)
217
case
TIMER0B: cbi(TCCR0A, COM0B1);
break
;
218
156: 84 bd
out
0x24, r24 ; 36
219
158: db cf rjmp .-74 ; 0x110 <digitalWrite+0x30>
220
15a: 84 b5
in
r24, 0x24 ; 36
221
15c: 8f 7d andi r24, 0xDF ; 223
222
15e: fb cf rjmp .-10 ; 0x156 <digitalWrite+0x76>
223
#endif
224
#if defined(TCCR2A) && defined(COM2A1)
225
case
TIMER2A: cbi(TCCR2A, COM2A1);
break
;
226
160: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__DATA_REGION_ORIGIN__+0x50>
227
164: 8f 77 andi r24, 0x7F ; 127
228
#endif
229
#if defined(TCCR2A) && defined(COM2B1)
230
case
TIMER2B: cbi(TCCR2A, COM2B1);
break
;
231
166: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0 <__DATA_REGION_ORIGIN__+0x50>
232
16a: d2 cf rjmp .-92 ; 0x110 <digitalWrite+0x30>
233
16c: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__DATA_REGION_ORIGIN__+0x50>
234
170: 8f 7d andi r24, 0xDF ; 223
235
172: f9 cf rjmp .-14 ; 0x166 <digitalWrite+0x86>
236
cli();
237
238
if
(val == LOW) {
239
*
out
&= ~bit;
240
}
else
{
241
*
out
|= bit;
242
174: 3e 2b or r19, r30
243
176: da cf rjmp .-76 ; 0x12c <digitalWrite+0x4c>
244
245
00000178 <micros>:
246
return
m;
247
}
248
249
unsigned
long
micros() {
250
unsigned
long
m;
251
uint8_t oldSREG = SREG, t;
252
178: 3f b7
in
r19, 0x3f ; 63
253
254
cli();
255
17a: f8 94 cli
256
m = timer0_overflow_count;
257
17c: 80 91 05 01 lds r24, 0x0105 ; 0x800105 <timer0_overflow_count>
258
180: 90 91 06 01 lds r25, 0x0106 ; 0x800106 <timer0_overflow_count+0x1>
259
184: a0 91 07 01 lds r26, 0x0107 ; 0x800107 <timer0_overflow_count+0x2>
260
188: b0 91 08 01 lds r27, 0x0108 ; 0x800108 <timer0_overflow_count+0x3>
261
#if defined(TCNT0)
262
t = TCNT0;
263
18c: 26 b5
in
r18, 0x26 ; 38
264
#else
265
#error TIMER 0 not defined
266
#endif
267
268
#ifdef TIFR0
269
if
((TIFR0 & _BV(TOV0)) && (t < 255))
270
18e: a8 9b sbis 0x15, 0 ; 21
271
190: 05 c0 rjmp .+10 ; 0x19c <micros+0x24>
272
192: 2f 3f cpi r18, 0xFF ; 255
273
194: 19 f0 breq .+6 ; 0x19c <micros+0x24>
274
m++;
275
196: 01 96 adiw r24, 0x01 ; 1
276
198: a1 1d adc r26, r1
277
19a: b1 1d adc r27, r1
278
#else
279
if
((TIFR & _BV(TOV0)) && (t < 255))
280
m++;
281
#endif
282
283
SREG = oldSREG;
284
19c: 3f bf
out
0x3f, r19 ; 63
285
286
return
((m << 8) + t) * (64 / clockCyclesPerMicrosecond());
287
19e: ba 2f mov r27, r26
288
1a0: a9 2f mov r26, r25
289
1a2: 98 2f mov r25, r24
290
1a4: 88 27 eor r24, r24
291
1a6: bc 01 movw r22, r24
292
1a8: cd 01 movw r24, r26
293
1aa: 62 0f add r22, r18
294
1ac: 71 1d adc r23, r1
295
1ae: 81 1d adc r24, r1
296
1b0: 91 1d adc r25, r1
297
1b2: 42 e0 ldi r20, 0x02 ; 2
298
1b4: 66 0f add r22, r22
299
1b6: 77 1f adc r23, r23
300
1b8: 88 1f adc r24, r24
301
1ba: 99 1f adc r25, r25
302
1bc: 4a 95 dec r20
303
1be: d1 f7 brne .-12 ; 0x1b4 <micros+0x3c>
304
}
305
1c0: 08 95 ret
306
307
000001c2 <delay.constprop.0>:
308
309
void
delay(unsigned
long
ms)
310
1c2: 8f 92 push r8
311
1c4: 9f 92 push r9
312
1c6: af 92 push r10
313
1c8: bf 92 push r11
314
1ca: cf 92 push r12
315
1cc: df 92 push r13
316
1ce: ef 92 push r14
317
1d0: ff 92 push r15
318
{
319
uint32_t start = micros();
320
1d2: 0e 94 bc 00 call 0x178 ; 0x178 <micros>
321
1d6: 4b 01 movw r8, r22
322
1d8: 5c 01 movw r10, r24
323
1da: 88 ee ldi r24, 0xE8 ; 232
324
1dc: c8 2e mov r12, r24
325
1de: 83 e0 ldi r24, 0x03 ; 3
326
1e0: d8 2e mov r13, r24
327
1e2: e1 2c mov r14, r1
328
1e4: f1 2c mov r15, r1
329
330
while
(ms > 0) {
331
yield();
332
while
( ms > 0 && (micros() - start) >= 1000) {
333
1e6: 0e 94 bc 00 call 0x178 ; 0x178 <micros>
334
1ea: 68 19 sub r22, r8
335
1ec: 79 09 sbc r23, r9
336
1ee: 8a 09 sbc r24, r10
337
1f0: 9b 09 sbc r25, r11
338
1f2: 68 3e cpi r22, 0xE8 ; 232
339
1f4: 73 40 sbci r23, 0x03 ; 3
340
1f6: 81 05 cpc r24, r1
341
1f8: 91 05 cpc r25, r1
342
1fa: a8 f3 brcs .-22 ; 0x1e6 <delay.constprop.0+0x24>
343
ms--;
344
1fc: 21 e0 ldi r18, 0x01 ; 1
345
1fe: c2 1a sub r12, r18
346
200: d1 08 sbc r13, r1
347
202: e1 08 sbc r14, r1
348
204: f1 08 sbc r15, r1
349
start += 1000;
350
206: 88 ee ldi r24, 0xE8 ; 232
351
208: 88 0e add r8, r24
352
20a: 83 e0 ldi r24, 0x03 ; 3
353
20c: 98 1e adc r9, r24
354
20e: a1 1c adc r10, r1
355
210: b1 1c adc r11, r1
356
{
357
uint32_t start = micros();
358
359
while
(ms > 0) {
360
yield();
361
while
( ms > 0 && (micros() - start) >= 1000) {
362
212: c1 14 cp r12, r1
363
214: d1 04 cpc r13, r1
364
216: e1 04 cpc r14, r1
365
218: f1 04 cpc r15, r1
366
21a: 29 f7 brne .-54 ; 0x1e6 <delay.constprop.0+0x24>
367
ms--;
368
start += 1000;
369
}
370
}
371
}
372
21c: ff 90 pop r15
373
21e: ef 90 pop r14
374
220: df 90 pop r13
375
222: cf 90 pop r12
376
224: bf 90 pop r11
377
226: af 90 pop r10
378
228: 9f 90 pop r9
379
22a: 8f 90 pop r8
380
22c: 08 95 ret
381
382
0000022e <__vector_16>:
383
#if defined(TIM0_OVF_vect)
384
ISR(TIM0_OVF_vect)
385
#else
386
ISR(TIMER0_OVF_vect)
387
#endif
388
{
389
22e: 1f 92 push r1
390
230: 0f 92 push r0
391
232: 0f b6
in
r0, 0x3f ; 63
392
234: 0f 92 push r0
393
236: 11 24 eor r1, r1
394
238: 2f 93 push r18
395
23a: 3f 93 push r19
396
23c: 8f 93 push r24
397
23e: 9f 93 push r25
398
240: af 93 push r26
399
242: bf 93 push r27
400
// copy these to local variables so they can be stored in registers
401
// (volatile variables must be read from memory on every access)
402
unsigned
long
m = timer0_millis;
403
244: 80 91 01 01 lds r24, 0x0101 ; 0x800101 <timer0_millis>
404
248: 90 91 02 01 lds r25, 0x0102 ; 0x800102 <timer0_millis+0x1>
405
24c: a0 91 03 01 lds r26, 0x0103 ; 0x800103 <timer0_millis+0x2>
406
250: b0 91 04 01 lds r27, 0x0104 ; 0x800104 <timer0_millis+0x3>
407
unsigned
char
f = timer0_fract;
408
254: 30 91 00 01 lds r19, 0x0100 ; 0x800100 <_edata>
409
410
m += MILLIS_INC;
411
f += FRACT_INC;
412
258: 23 e0 ldi r18, 0x03 ; 3
413
25a: 23 0f add r18, r19
414
if
(f >= FRACT_MAX) {
415
25c: 2d 37 cpi r18, 0x7D ; 125
416
25e: 58 f5 brcc .+86 ; 0x2b6 <__vector_16+0x88>
417
// copy these to local variables so they can be stored in registers
418
// (volatile variables must be read from memory on every access)
419
unsigned
long
m = timer0_millis;
420
unsigned
char
f = timer0_fract;
421
422
m += MILLIS_INC;
423
260: 01 96 adiw r24, 0x01 ; 1
424
262: a1 1d adc r26, r1
425
264: b1 1d adc r27, r1
426
if
(f >= FRACT_MAX) {
427
f -= FRACT_MAX;
428
m += 1;
429
}
430
431
timer0_fract = f;
432
266: 20 93 00 01 sts 0x0100, r18 ; 0x800100 <_edata>
433
timer0_millis = m;
434
26a: 80 93 01 01 sts 0x0101, r24 ; 0x800101 <timer0_millis>
435
26e: 90 93 02 01 sts 0x0102, r25 ; 0x800102 <timer0_millis+0x1>
436
272: a0 93 03 01 sts 0x0103, r26 ; 0x800103 <timer0_millis+0x2>
437
276: b0 93 04 01 sts 0x0104, r27 ; 0x800104 <timer0_millis+0x3>
438
timer0_overflow_count++;
439
27a: 80 91 05 01 lds r24, 0x0105 ; 0x800105 <timer0_overflow_count>
440
27e: 90 91 06 01 lds r25, 0x0106 ; 0x800106 <timer0_overflow_count+0x1>
441
282: a0 91 07 01 lds r26, 0x0107 ; 0x800107 <timer0_overflow_count+0x2>
442
286: b0 91 08 01 lds r27, 0x0108 ; 0x800108 <timer0_overflow_count+0x3>
443
28a: 01 96 adiw r24, 0x01 ; 1
444
28c: a1 1d adc r26, r1
445
28e: b1 1d adc r27, r1
446
290: 80 93 05 01 sts 0x0105, r24 ; 0x800105 <timer0_overflow_count>
447
294: 90 93 06 01 sts 0x0106, r25 ; 0x800106 <timer0_overflow_count+0x1>
448
298: a0 93 07 01 sts 0x0107, r26 ; 0x800107 <timer0_overflow_count+0x2>
449
29c: b0 93 08 01 sts 0x0108, r27 ; 0x800108 <timer0_overflow_count+0x3>
450
}
451
2a0: bf 91 pop r27
452
2a2: af 91 pop r26
453
2a4: 9f 91 pop r25
454
2a6: 8f 91 pop r24
455
2a8: 3f 91 pop r19
456
2aa: 2f 91 pop r18
457
2ac: 0f 90 pop r0
458
2ae: 0f be
out
0x3f, r0 ; 63
459
2b0: 0f 90 pop r0
460
2b2: 1f 90 pop r1
461
2b4: 18 95 reti
462
unsigned
char
f = timer0_fract;
463
464
m += MILLIS_INC;
465
f += FRACT_INC;
466
if
(f >= FRACT_MAX) {
467
f -= FRACT_MAX;
468
2b6: 26 e8 ldi r18, 0x86 ; 134
469
2b8: 23 0f add r18, r19
470
m += 1;
471
2ba: 02 96 adiw r24, 0x02 ; 2
472
2bc: a1 1d adc r26, r1
473
2be: b1 1d adc r27, r1
474
2c0: d2 cf rjmp .-92 ; 0x266 <__vector_16+0x38>
475
476
000002c2 <main>:
477
478
void
init()
479
{
480
// this needs to be called before setup() or some functions won't
481
// work there
482
sei();
483
2c2: 78 94 sei
484
485
// on the ATmega168, timer 0 is also used for fast hardware pwm
486
// (using phase-correct PWM would mean that timer 0 overflowed half as often
487
// resulting in different millis() behavior on the ATmega8 and ATmega168)
488
#if defined(TCCR0A) && defined(WGM01)
489
sbi(TCCR0A, WGM01);
490
2c4: 84 b5
in
r24, 0x24 ; 36
491
2c6: 82 60 ori r24, 0x02 ; 2
492
2c8: 84 bd
out
0x24, r24 ; 36
493
sbi(TCCR0A, WGM00);
494
2ca: 84 b5
in
r24, 0x24 ; 36
495
2cc: 81 60 ori r24, 0x01 ; 1
496
2ce: 84 bd
out
0x24, r24 ; 36
497
// this combination is for the standard atmega8
498
sbi(TCCR0, CS01);
499
sbi(TCCR0, CS00);
500
#elif defined(TCCR0B) && defined(CS01) && defined(CS00)
501
// this combination is for the standard 168/328/1280/2560
502
sbi(TCCR0B, CS01);
503
2d0: 85 b5
in
r24, 0x25 ; 37
504
2d2: 82 60 ori r24, 0x02 ; 2
505
2d4: 85 bd
out
0x25, r24 ; 37
506
sbi(TCCR0B, CS00);
507
2d6: 85 b5
in
r24, 0x25 ; 37
508
2d8: 81 60 ori r24, 0x01 ; 1
509
2da: 85 bd
out
0x25, r24 ; 37
510
511
// enable timer 0 overflow interrupt
512
#if defined(TIMSK) && defined(TOIE0)
513
sbi(TIMSK, TOIE0);
514
#elif defined(TIMSK0) && defined(TOIE0)
515
sbi(TIMSK0, TOIE0);
516
2dc: 80 91 6e 00 lds r24, 0x006E ; 0x80006e <__DATA_REGION_ORIGIN__+0xe>
517
2e0: 81 60 ori r24, 0x01 ; 1
518
2e2: 80 93 6e 00 sts 0x006E, r24 ; 0x80006e <__DATA_REGION_ORIGIN__+0xe>
519
// this is better for motors as it ensures an even waveform
520
// note, however, that fast pwm mode can achieve a frequency of up
521
// 8 MHz (with a 16 MHz clock) at 50% duty cycle
522
523
#if defined(TCCR1B) && defined(CS11) && defined(CS10)
524
TCCR1B = 0;
525
2e6: 10 92 81 00 sts 0x0081, r1 ; 0x800081 <__DATA_REGION_ORIGIN__+0x21>
526
527
// set timer 1 prescale factor to 64
528
sbi(TCCR1B, CS11);
529
2ea: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__DATA_REGION_ORIGIN__+0x21>
530
2ee: 82 60 ori r24, 0x02 ; 2
531
2f0: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__DATA_REGION_ORIGIN__+0x21>
532
#if F_CPU >= 8000000L
533
sbi(TCCR1B, CS10);
534
2f4: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__DATA_REGION_ORIGIN__+0x21>
535
2f8: 81 60 ori r24, 0x01 ; 1
536
2fa: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__DATA_REGION_ORIGIN__+0x21>
537
sbi(TCCR1, CS10);
538
#endif
539
#endif
540
// put timer 1 in 8-bit phase correct pwm mode
541
#if defined(TCCR1A) && defined(WGM10)
542
sbi(TCCR1A, WGM10);
543
2fe: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__DATA_REGION_ORIGIN__+0x20>
544
302: 81 60 ori r24, 0x01 ; 1
545
304: 80 93 80 00 sts 0x0080, r24 ; 0x800080 <__DATA_REGION_ORIGIN__+0x20>
546
547
// set timer 2 prescale factor to 64
548
#if defined(TCCR2) && defined(CS22)
549
sbi(TCCR2, CS22);
550
#elif defined(TCCR2B) && defined(CS22)
551
sbi(TCCR2B, CS22);
552
308: 80 91 b1 00 lds r24, 0x00B1 ; 0x8000b1 <__DATA_REGION_ORIGIN__+0x51>
553
30c: 84 60 ori r24, 0x04 ; 4
554
30e: 80 93 b1 00 sts 0x00B1, r24 ; 0x8000b1 <__DATA_REGION_ORIGIN__+0x51>
555
556
// configure timer 2 for phase correct pwm (8-bit)
557
#if defined(TCCR2) && defined(WGM20)
558
sbi(TCCR2, WGM20);
559
#elif defined(TCCR2A) && defined(WGM20)
560
sbi(TCCR2A, WGM20);
561
312: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__DATA_REGION_ORIGIN__+0x50>
562
316: 81 60 ori r24, 0x01 ; 1
563
318: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0 <__DATA_REGION_ORIGIN__+0x50>
564
#endif
565
566
#if defined(ADCSRA)
567
// set a2d prescaler so we are inside the desired 50-200 KHz range.
568
#if F_CPU >= 16000000 // 16 MHz / 128 = 125 KHz
569
sbi(ADCSRA, ADPS2);
570
31c: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a>
571
320: 84 60 ori r24, 0x04 ; 4
572
322: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a>
573
sbi(ADCSRA, ADPS1);
574
326: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a>
575
32a: 82 60 ori r24, 0x02 ; 2
576
32c: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a>
577
sbi(ADCSRA, ADPS0);
578
330: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a>
579
334: 81 60 ori r24, 0x01 ; 1
580
336: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a>
581
cbi(ADCSRA, ADPS2);
582
cbi(ADCSRA, ADPS1);
583
sbi(ADCSRA, ADPS0);
584
#endif
585
// enable a2d conversions
586
sbi(ADCSRA, ADEN);
587
33a: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a>
588
33e: 80 68 ori r24, 0x80 ; 128
589
340: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a>
590
// here so they can be used as normal digital i/o; they will be
591
// reconnected in Serial.begin()
592
#if defined(UCSRB)
593
UCSRB = 0;
594
#elif defined(UCSR0B)
595
UCSR0B = 0;
596
344: 10 92 c1 00 sts 0x00C1, r1 ; 0x8000c1 <__DATA_REGION_ORIGIN__+0x61>
597
#include "wiring_private.h"
598
#include "pins_arduino.h"
599
600
void
pinMode(uint8_t pin, uint8_t mode)
601
{
602
uint8_t bit = digitalPinToBitMask(pin);
603
348: e1 eb ldi r30, 0xB1 ; 177
604
34a: f0 e0 ldi r31, 0x00 ; 0
605
34c: 24 91 lpm r18, Z
606
uint8_t port = digitalPinToPort(pin);
607
34e: ed e9 ldi r30, 0x9D ; 157
608
350: f0 e0 ldi r31, 0x00 ; 0
609
352: 84 91 lpm r24, Z
610
volatile uint8_t *reg, *
out
;
611
612
if
(port == NOT_A_PIN)
return
;
613
354: 88 23 and r24, r24
614
356: 99 f0 breq .+38 ; 0x37e <main+0xbc>
615
616
// JWS: can I let the optimizer do this?
617
reg = portModeRegister(port);
618
358: 90 e0 ldi r25, 0x00 ; 0
619
35a: 88 0f add r24, r24
620
35c: 99 1f adc r25, r25
621
35e: fc 01 movw r30, r24
622
360: ea 57 subi r30, 0x7A ; 122
623
362: ff 4f sbci r31, 0xFF ; 255
624
364: a5 91 lpm r26, Z+
625
366: b4 91 lpm r27, Z
626
out
= portOutputRegister(port);
627
368: fc 01 movw r30, r24
628
36a: e4 58 subi r30, 0x84 ; 132
629
36c: ff 4f sbci r31, 0xFF ; 255
630
36e: 85 91 lpm r24, Z+
631
370: 94 91 lpm r25, Z
632
cli();
633
*reg &= ~bit;
634
*
out
|= bit;
635
SREG = oldSREG;
636
}
else
{
637
uint8_t oldSREG = SREG;
638
372: 8f b7
in
r24, 0x3f ; 63
639
cli();
640
374: f8 94 cli
641
*reg |= bit;
642
376: ec 91 ld r30, X
643
378: e2 2b or r30, r18
644
37a: ec 93 st X, r30
645
SREG = oldSREG;
646
37c: 8f bf
out
0x3f, r24 ; 63
647
648
setup
();
649
650
for
(;;) {
651
loop
();
652
if
(serialEventRun) serialEventRun();
653
37e: c0 e0 ldi r28, 0x00 ; 0
654
380: d0 e0 ldi r29, 0x00 ; 0
655
pinMode(led, OUTPUT);
656
}
657
658
// the loop routine runs over and over again forever:
659
void
loop
() {
660
digitalWrite(led, HIGH);
// turn the LED on (HIGH is the voltage level)
661
382: 61 e0 ldi r22, 0x01 ; 1
662
384: 8d e0 ldi r24, 0x0D ; 13
663
386: 0e 94 70 00 call 0xe0 ; 0xe0 <digitalWrite>
664
delay(1000);
// wait for a second
665
38a: 0e 94 e1 00 call 0x1c2 ; 0x1c2 <delay.constprop.0>
666
digitalWrite(led, LOW);
// turn the LED off by making the voltage LOW
667
38e: 60 e0 ldi r22, 0x00 ; 0
668
390: 8d e0 ldi r24, 0x0D ; 13
669
392: 0e 94 70 00 call 0xe0 ; 0xe0 <digitalWrite>
670
delay(1000);
// wait for a second
671
396: 0e 94 e1 00 call 0x1c2 ; 0x1c2 <delay.constprop.0>
672
39a: 20 97 sbiw r28, 0x00 ; 0
673
39c: 91 f3 breq .-28 ; 0x382 <main+0xc0>
674
39e: 0e 94 00 00 call 0 ; 0x0 <__vectors>
675
3a2: ef cf rjmp .-34 ; 0x382 <main+0xc0>
676
677
000003a4 <_exit>:
678
3a4: f8 94 cli
679
680
000003a6 <__stop_program>:
681
3a6: ff cf rjmp .-2 ; 0x3a6 <__stop_program>
"Номера строк исходника" - это хорошо. Но эта функция - для пошаговой отладки. Для привязки строк исходника к результирующему коду отладчиком. При имеющемся в наличии оригинальном файле исходника.
Если в наличии исходника нет, то сами номера строк (без их содержимого) - малоинформативны.
Или в ардуине в elf и содержимое строк исходника может сохраняться? Но ведь в обсуждаемом случае (когда автор не хочет отдавать исходник), а значит - автор кода позаботится о том, чтобы этих строк в .elf не было. Так что: из .elf только дизасм.
И из elf-a - сильно сомневаюсь что его можно получить. Из elf-а - только дизасм. Путаете "листинг" с "дизассемблером".
Теоретики... практики... Ну да.
Вот именно: "бумажная распечатка текста компьютерной программы или её части."
Не придирайся. Признайся, что не понимал что это такое .
Это да. Ну не понимаю я эту современную молодёжь.)