~gabe/flashlight-firmware/anduril2
» Revision
123.1.1
(compared to revision 169.1.1)
: Tamagotchi/7135x8v2/default/7135x8v26.lss
« back to all changes in this revision
Viewing changes to Tamagotchi/7135x8v2/default/7135x8v26.lss
- browse files at revision 123.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 123.1.1
- Committer: Selene Scriven
- Date: 2015-03-17 08:56:50 UTC
- mto: This revision was merged to the branch mainline in revision 124.
- Revision ID: ubuntu@toykeeper.net-20150317085650-s89wr9h28n2co7z1
Added TheStar firmwares from _the_
- files added:
- JonnyC/STAR/SRK_with_ramp
- files removed:
- DrJones/MiniDrv/meta
- Mike_C
- Mike_C/X85
- Tamagotchi
- Tamagotchi/7135x8v2
- Tamagotchi/7135x8v2/default
- Tamagotchi/7135x8v2/default/dep
- Tamagotchi/7135x8v2/zip
- Tido
- Tido/BLF-VLD
- Tido/BLF-VLD/.settings
- Tido/BLF-VLD/Default
- Tido/BLF-VLD/Fixed Modes
- Tido/BLF-VLD/Programmable
- Tido/BLF-VLD/Simple
- Tido/BLF-VLD/docs
- Tom_E/eswitch-13
- Tom_E/narsil
- Tom_E/narsil/.vs
- Tom_E/narsil/.vs/Narsil
- Tom_E/narsil/.vs/Narsil/v14
- Tom_E/narsil/Narsil
- Tom_E/narsil/Narsil/Debug
- Tom_E/narsil/Narsil/Release
- ToyKeeper/STAR_1mode
- ToyKeeper/battcheck/readings
- ToyKeeper/bistro
- ToyKeeper/blf-a6/cypreus2
- ToyKeeper/uv
- odd
- odd/MGdriver
- pilotdog68
- pilotdog68/xintd-x3
- files renamed:
- Tom_E/eswitch-13/README => Tom_E/README
- Tom_E/eswitch-13/eswitch.c => Tom_E/eswitch.c
- Tom_E/eswitch-13/eswitch.hex => Tom_E/eswitch.hex
- bin/level_calc.py => ToyKeeper/Ferrero_Rocher/level_calc.py
- files modified:
- DrJones/luxdrv/luxdrv-030.c
added
removed
Tamagotchi/7135x8v2/default/7135x8v26.lss
1
2
7135x8v26.elf: file format elf32-avr
3
4
Sections:
5
Idx Name Size VMA LMA File off Algn
6
0 .text 000003e2 00000000 00000000 00000094 2**1
7
CONTENTS, ALLOC, LOAD, READONLY, CODE
8
1 .data 00000016 00800060 000003e2 00000476 2**0
9
CONTENTS, ALLOC, LOAD, DATA
10
2 .bss 00000001 00800076 00800076 0000048c 2**0
11
ALLOC
12
3 .stab 000006b4 00000000 00000000 0000048c 2**2
13
CONTENTS, READONLY, DEBUGGING
14
4 .stabstr 00000085 00000000 00000000 00000b40 2**0
15
CONTENTS, READONLY, DEBUGGING
16
5 .debug_aranges 00000090 00000000 00000000 00000bc8 2**3
17
CONTENTS, READONLY, DEBUGGING
18
6 .debug_info 00000a65 00000000 00000000 00000c58 2**0
19
CONTENTS, READONLY, DEBUGGING
20
7 .debug_abbrev 00000338 00000000 00000000 000016bd 2**0
21
CONTENTS, READONLY, DEBUGGING
22
8 .debug_line 00000467 00000000 00000000 000019f5 2**0
23
CONTENTS, READONLY, DEBUGGING
24
9 .debug_frame 00000114 00000000 00000000 00001e5c 2**2
25
CONTENTS, READONLY, DEBUGGING
26
10 .debug_str 000002ec 00000000 00000000 00001f70 2**0
27
CONTENTS, READONLY, DEBUGGING
28
11 .debug_loc 0000028c 00000000 00000000 0000225c 2**0
29
CONTENTS, READONLY, DEBUGGING
30
12 .debug_ranges 000000c0 00000000 00000000 000024e8 2**0
31
CONTENTS, READONLY, DEBUGGING
32
33
Disassembly of section .text:
34
35
00000000 <__vectors>:
36
0: 09 c0 rjmp .+18 ; 0x14 <__ctors_end>
37
2: 21 c0 rjmp .+66 ; 0x46 <__bad_interrupt>
38
4: 20 c0 rjmp .+64 ; 0x46 <__bad_interrupt>
39
6: 1f c0 rjmp .+62 ; 0x46 <__bad_interrupt>
40
8: 1e c0 rjmp .+60 ; 0x46 <__bad_interrupt>
41
a: 1d c0 rjmp .+58 ; 0x46 <__bad_interrupt>
42
c: 1c c0 rjmp .+56 ; 0x46 <__bad_interrupt>
43
e: 1b c0 rjmp .+54 ; 0x46 <__bad_interrupt>
44
10: 93 c0 rjmp .+294 ; 0x138 <__vector_8>
45
12: 9e c0 rjmp .+316 ; 0x150 <__vector_9>
46
47
00000014 <__ctors_end>:
48
14: 11 24 eor r1, r1
49
16: 1f be out 0x3f, r1 ; 63
50
18: cf e9 ldi r28, 0x9F ; 159
51
1a: cd bf out 0x3d, r28 ; 61
52
53
0000001c <__do_copy_data>:
54
1c: 10 e0 ldi r17, 0x00 ; 0
55
1e: a0 e6 ldi r26, 0x60 ; 96
56
20: b0 e0 ldi r27, 0x00 ; 0
57
22: e2 ee ldi r30, 0xE2 ; 226
58
24: f3 e0 ldi r31, 0x03 ; 3
59
26: 02 c0 rjmp .+4 ; 0x2c <__do_copy_data+0x10>
60
28: 05 90 lpm r0, Z+
61
2a: 0d 92 st X+, r0
62
2c: a6 37 cpi r26, 0x76 ; 118
63
2e: b1 07 cpc r27, r17
64
30: d9 f7 brne .-10 ; 0x28 <__do_copy_data+0xc>
65
66
00000032 <__do_clear_bss>:
67
32: 10 e0 ldi r17, 0x00 ; 0
68
34: a6 e7 ldi r26, 0x76 ; 118
69
36: b0 e0 ldi r27, 0x00 ; 0
70
38: 01 c0 rjmp .+2 ; 0x3c <.do_clear_bss_start>
71
72
0000003a <.do_clear_bss_loop>:
73
3a: 1d 92 st X+, r1
74
75
0000003c <.do_clear_bss_start>:
76
3c: a7 37 cpi r26, 0x77 ; 119
77
3e: b1 07 cpc r27, r17
78
40: e1 f7 brne .-8 ; 0x3a <.do_clear_bss_loop>
79
42: cb d0 rcall .+406 ; 0x1da <main>
80
44: cc c1 rjmp .+920 ; 0x3de <_exit>
81
82
00000046 <__bad_interrupt>:
83
46: dc cf rjmp .-72 ; 0x0 <__vectors>
84
85
00000048 <WriteEEPROMByte>:
86
#endif
87
88
89
static NOINLINE void WriteEEPROMByte(uint8_t adress, uint8_t byte)
90
{
91
while(EECR & _BV(EEPE));
92
48: e1 99 sbic 0x1c, 1 ; 28
93
4a: fe cf rjmp .-4 ; 0x48 <WriteEEPROMByte>
94
EEAR = adress; // set address
95
4c: 8e bb out 0x1e, r24 ; 30
96
EEDR = byte; // set data
97
4e: 6d bb out 0x1d, r22 ; 29
98
cli(); // disable interrupts
99
50: f8 94 cli
100
EECR |= _BV(EEMWE); // set "write enable" bit
101
52: e2 9a sbi 0x1c, 2 ; 28
102
EECR |= _BV(EEWE); // set "write" bit
103
54: e1 9a sbi 0x1c, 1 ; 28
104
sei();
105
56: 78 94 sei
106
}
107
58: 08 95 ret
108
109
0000005a <ReadEEPROMByte>:
110
111
static NOINLINE uint8_t ReadEEPROMByte(uint8_t adress)
112
{
113
while(EECR & 0x02);
114
5a: e1 99 sbic 0x1c, 1 ; 28
115
5c: fe cf rjmp .-4 ; 0x5a <ReadEEPROMByte>
116
EEAR = adress; // set address
117
5e: 8e bb out 0x1e, r24 ; 30
118
EECR |= _BV(EERE); // set "read enable" bit
119
60: e0 9a sbi 0x1c, 0 ; 28
120
return (EEDR);
121
62: 8d b3 in r24, 0x1d ; 29
122
}
123
64: 08 95 ret
124
125
00000066 <all_off>:
126
while(--ms);
127
}
128
129
static NOINLINE void all_off(void) // ��������� ������ ���
130
{
131
LED_PORT = PB_CONFIG;
132
66: 80 e3 ldi r24, 0x30 ; 48
133
68: 88 bb out 0x18, r24 ; 24
134
OCR0A = 0x00;
135
6a: 16 be out 0x36, r1 ; 54
136
}
137
6c: 08 95 ret
138
139
0000006e <cpu_div>:
140
141
#ifndef FREQMOON_OFF
142
static NOINLINE void cpu_div(void) // ������������� �������� �������� �������
143
{
144
CLKPR = 0x80;
145
6e: 80 e8 ldi r24, 0x80 ; 128
146
70: 86 bd out 0x26, r24 ; 38
147
CLKPR = 0x02;
148
72: 82 e0 ldi r24, 0x02 ; 2
149
74: 86 bd out 0x26, r24 ; 38
150
}
151
76: 08 95 ret
152
153
00000078 <pwr_down>:
154
#endif
155
}
156
157
static NOINLINE void pwr_down(void)
158
{
159
cli();
160
78: f8 94 cli
161
ADCSRA = 0x00; // ��������� ADC
162
7a: 16 b8 out 0x06, r1 ; 6
163
TCCR0A = 0x00; // ��������� ������
164
7c: 1f bc out 0x2f, r1 ; 47
165
TCCR0B = 0x00; // ��������� ������
166
7e: 13 be out 0x33, r1 ; 51
167
PRR = 0x03; // 0000 0011
168
80: 83 e0 ldi r24, 0x03 ; 3
169
82: 85 bd out 0x25, r24 ; 37
170
DDRB = 0x00; // �������� ����
171
84: 17 ba out 0x17, r1 ; 23
172
PORTB = 0x00;
173
86: 18 ba out 0x18, r1 ; 24
174
MCUCR = 0x30; // PwrDown
175
88: 80 e3 ldi r24, 0x30 ; 48
176
8a: 85 bf out 0x35, r24 ; 53
177
sleep_cpu();
178
8c: 88 95 sleep
179
}
180
8e: 08 95 ret
181
182
00000090 <set_mode>:
183
}
184
185
186
static NOINLINE void set_mode(uint8_t mode) // ������ ����� ��� ������ ���� ��������� SetMod3();
187
{
188
switch (mode)
189
90: 81 30 cpi r24, 0x01 ; 1
190
92: 59 f0 breq .+22 ; 0xaa <__stack+0xb>
191
94: 81 30 cpi r24, 0x01 ; 1
192
96: 28 f0 brcs .+10 ; 0xa2 <__stack+0x3>
193
98: 82 30 cpi r24, 0x02 ; 2
194
9a: 49 f0 breq .+18 ; 0xae <__stack+0xf>
195
9c: 83 30 cpi r24, 0x03 ; 3
196
9e: 71 f4 brne .+28 ; 0xbc <__stack+0x1d>
197
a0: 08 c0 rjmp .+16 ; 0xb2 <__stack+0x13>
198
{
199
case 0:
200
SetMod0();
201
a2: 80 e3 ldi r24, 0x30 ; 48
202
a4: 88 bb out 0x18, r24 ; 24
203
a6: 85 e5 ldi r24, 0x55 ; 85
204
a8: 07 c0 rjmp .+14 ; 0xb8 <__stack+0x19>
205
break;
206
case 1:
207
SetMod1();
208
aa: 80 e3 ldi r24, 0x30 ; 48
209
ac: 03 c0 rjmp .+6 ; 0xb4 <__stack+0x15>
210
break;
211
case 2:
212
SetMod2();
213
ae: 88 e3 ldi r24, 0x38 ; 56
214
b0: 01 c0 rjmp .+2 ; 0xb4 <__stack+0x15>
215
break;
216
#if MAX_MODES >= 3
217
case 3:
218
SetMod3();
219
b2: 8a e3 ldi r24, 0x3A ; 58
220
b4: 88 bb out 0x18, r24 ; 24
221
b6: 8f ef ldi r24, 0xFF ; 255
222
b8: 86 bf out 0x36, r24 ; 54
223
break;
224
ba: 08 95 ret
225
case 4:
226
SetMod4();
227
break;
228
#endif
229
default:
230
pwr_down();
231
bc: dd df rcall .-70 ; 0x78 <pwr_down>
232
be: 08 95 ret
233
234
000000c0 <delay_ms>:
235
#else
236
//round up by default
237
__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
238
#endif
239
240
__builtin_avr_delay_cycles(__ticks_dc);
241
c0: ef ea ldi r30, 0xAF ; 175
242
c2: f4 e0 ldi r31, 0x04 ; 4
243
c4: 31 97 sbiw r30, 0x01 ; 1
244
c6: f1 f7 brne .-4 ; 0xc4 <delay_ms+0x4>
245
c8: 00 c0 rjmp .+0 ; 0xca <delay_ms+0xa>
246
ca: 00 00 nop
247
}
248
249
static NOINLINE void delay_ms(uint8_t ms) // ��������� ���, ����� ������ ����� ��������
250
{
251
do { _delay_ms(1); }
252
while(--ms);
253
cc: 81 50 subi r24, 0x01 ; 1
254
ce: c1 f7 brne .-16 ; 0xc0 <delay_ms>
255
}
256
d0: 08 95 ret
257
258
000000d2 <delay_sec.constprop.0>:
259
d2: 8f e3 ldi r24, 0x3F ; 63
260
d4: 90 e4 ldi r25, 0x40 ; 64
261
d6: a7 e0 ldi r26, 0x07 ; 7
262
d8: 81 50 subi r24, 0x01 ; 1
263
da: 90 40 sbci r25, 0x00 ; 0
264
dc: a0 40 sbci r26, 0x00 ; 0
265
de: e1 f7 brne .-8 ; 0xd8 <delay_sec.constprop.0+0x6>
266
e0: 00 c0 rjmp .+0 ; 0xe2 <delay_sec.constprop.0+0x10>
267
e2: 00 00 nop
268
269
static NOINLINE void delay_sec(uint8_t ms)
270
{
271
do { _delay_ms(495); }
272
while(--ms);
273
}
274
e4: 08 95 ret
275
276
000000e6 <std_loop>:
277
278
static NOINLINE void std_loop(void)
279
{
280
while(1)
281
{
282
set_mode(current_mode);
283
e6: 85 2d mov r24, r5
284
e8: d3 df rcall .-90 ; 0x90 <set_mode>
285
if (IsNewMode())
286
ea: 01 ff sbrs r16, 1
287
ec: 0d c0 rjmp .+26 ; 0x108 <std_loop+0x22>
288
{
289
#ifndef NOMEM
290
#ifdef WEAR_LEWELING
291
delay_sec(1);
292
ee: f1 df rcall .-30 ; 0xd2 <delay_sec.constprop.0>
293
save_byte(CMODE_ADR, current_mode);
294
f0: 65 2d mov r22, r5
295
296
#ifndef NOMEM
297
#ifdef WEAR_LEWELING
298
static INLINE void save_byte(uint8_t startadr, uint8_t data)
299
{
300
uint8_t old_eeprom_pos = eeprom_pos;
301
f2: c0 91 76 00 lds r28, 0x0076
302
eeprom_pos=(eeprom_pos + 1) & 0x1F;
303
f6: 8c 2f mov r24, r28
304
f8: 8f 5f subi r24, 0xFF ; 255
305
fa: 8f 71 andi r24, 0x1F ; 31
306
fc: 80 93 76 00 sts 0x0076, r24
307
WriteEEPROMByte((eeprom_pos + startadr), data);
308
100: a3 df rcall .-186 ; 0x48 <WriteEEPROMByte>
309
WriteEEPROMByte((old_eeprom_pos + startadr), 0xFF);
310
102: 8c 2f mov r24, r28
311
104: 6f ef ldi r22, 0xFF ; 255
312
106: a0 df rcall .-192 ; 0x48 <WriteEEPROMByte>
313
WriteEEPROMByte(CFG_CURRENTMODE, current_mode);
314
#endif
315
#endif
316
}
317
#ifdef THEMPERATURE_CONTROL
318
calibrator10 = adch_temp;
319
108: a8 2c mov r10, r8
320
calibrator11 = calibrator10;
321
10a: b8 2c mov r11, r8
322
#endif
323
delay_ms(3);
324
10c: 83 e0 ldi r24, 0x03 ; 3
325
10e: d8 df rcall .-80 ; 0xc0 <delay_ms>
326
}
327
110: ea cf rjmp .-44 ; 0xe6 <std_loop>
328
329
00000112 <read_byte.constprop.1>:
330
static NOINLINE uint8_t read_byte(uint8_t startadr)
331
{
332
uint8_t eepdata;
333
while(1)
334
{
335
eepdata = ReadEEPROMByte(eeprom_pos + startadr);
336
112: 80 91 76 00 lds r24, 0x0076
337
116: a1 df rcall .-190 ; 0x5a <ReadEEPROMByte>
338
118: 90 91 76 00 lds r25, 0x0076
339
if((eepdata != 0xFF) || (eeprom_pos >= SIZE))
340
11c: 8f 3f cpi r24, 0xFF ; 255
341
11e: 31 f4 brne .+12 ; 0x12c <read_byte.constprop.1+0x1a>
342
120: 90 32 cpi r25, 0x20 ; 32
343
122: 20 f4 brcc .+8 ; 0x12c <read_byte.constprop.1+0x1a>
344
break;
345
eeprom_pos++;
346
124: 9f 5f subi r25, 0xFF ; 255
347
126: 90 93 76 00 sts 0x0076, r25
348
12a: f3 cf rjmp .-26 ; 0x112 <read_byte.constprop.1>
349
}
350
if (eeprom_pos < SIZE)
351
12c: 90 32 cpi r25, 0x20 ; 32
352
12e: 18 f0 brcs .+6 ; 0x136 <read_byte.constprop.1+0x24>
353
return eepdata;
354
else
355
eeprom_pos = 0;
356
130: 10 92 76 00 sts 0x0076, r1
357
return 0;
358
134: 80 e0 ldi r24, 0x00 ; 0
359
}
360
136: 08 95 ret
361
362
00000138 <__vector_8>:
363
WDTCR = (_BV(WDCE) | _BV(WDE));
364
WDTCR = (_BV(WDTIE) | WDTO_250MS);
365
}
366
367
ISR(WDT_vect)
368
{
369
138: 1f 92 push r1
370
13a: 0f 92 push r0
371
13c: 0f b6 in r0, 0x3f ; 63
372
13e: 0f 92 push r0
373
140: 11 24 eor r1, r1
374
ClearNewMode();
375
142: 0d 7f andi r16, 0xFD ; 253
376
short_off_counter = 0;
377
144: 22 24 eor r2, r2
378
if (current_mode == MAX_MODES) current_mode--;
379
#else
380
if (current_mode == 0) current_mode++;
381
#endif
382
#endif
383
}
384
146: 0f 90 pop r0
385
148: 0f be out 0x3f, r0 ; 63
386
14a: 0f 90 pop r0
387
14c: 1f 90 pop r1
388
14e: 18 95 reti
389
390
00000150 <__vector_9>:
391
}
392
#endif
393
394
395
ISR (ADC_vect)
396
{
397
150: 1f 92 push r1
398
152: 0f 92 push r0
399
154: 0f b6 in r0, 0x3f ; 63
400
156: 0f 92 push r0
401
158: 11 24 eor r1, r1
402
15a: 8f 93 push r24
403
15c: 9f 93 push r25
404
uint8_t adch_val = ADCH;
405
15e: 85 b1 in r24, 0x05 ; 5
406
}
407
408
#ifdef THEMPERATURE_CONTROL
409
static INLINE void switch_adc_in(uint8_t is_temp)
410
{
411
if (is_temp) // ���� �����������
412
160: 00 ff sbrs r16, 0
413
162: 02 c0 rjmp .+4 ; 0x168 <__vector_9+0x18>
414
#ifdef THERMVD
415
ADMUX = 0x62; // 0110 0010 PB4 Vref = 1.1V
416
#else
417
ADMUX = 0x22; // 0010 0010 PB4 Vref = Vcc
418
164: 92 e2 ldi r25, 0x22 ; 34
419
166: 01 c0 rjmp .+2 ; 0x16a <__vector_9+0x1a>
420
#endif
421
else
422
ADMUX = 0x61; // 0110 0001 PB2 Vref = 1.1V
423
168: 91 e6 ldi r25, 0x61 ; 97
424
16a: 97 b9 out 0x07, r25 ; 7
425
uint8_t adch_val = ADCH;
426
427
#ifdef THEMPERATURE_CONTROL
428
switch_adc_in(IsMeasureThemp());//
429
430
if(IsMeasureThemp())
431
16c: 00 ff sbrs r16, 0
432
16e: 0b c0 rjmp .+22 ; 0x186 <__vector_9+0x36>
433
{
434
if (MAX_THEMP) // ���� 0 - ��������� ����� ������
435
170: 9c 2d mov r25, r12
436
172: cc 20 and r12, r12
437
174: 31 f0 breq .+12 ; 0x182 <__vector_9+0x32>
438
{
439
#ifdef REVERSE_SW
440
if(adch_val < (uint8_t)(MAX_THEMP + current_mode)) // ������ 0 - ����� 3 - ������
441
176: 95 0d add r25, r5
442
178: 89 17 cp r24, r25
443
17a: 10 f4 brcc .+4 ; 0x180 <__vector_9+0x30>
444
#else
445
if(adch_val < (uint8_t)(MAX_THEMP - current_mode)) // ������ 0 - ������ 3 - �����
446
#endif
447
tick_temp++; // ���� ����������� ������ - �������� �������, ����� ���������, ��� ��� �� ������
448
17c: 93 94 inc r9
449
17e: 01 c0 rjmp .+2 ; 0x182 <__vector_9+0x32>
450
else
451
tick_temp = 0; // ���� ����������� ��������������� - �����
452
180: 99 24 eor r9, r9
453
}
454
adch_temp = adch_val;
455
182: 88 2e mov r8, r24
456
184: 06 c0 rjmp .+12 ; 0x192 <__vector_9+0x42>
457
}
458
else
459
{
460
#endif
461
if(adch_val < OFF_VOLTAGE)
462
186: 8d 37 cpi r24, 0x7D ; 125
463
188: 10 f4 brcc .+4 ; 0x18e <__vector_9+0x3e>
464
tick_volt++; // ���� ������� ���� - �������� �������, ����� ���������, ��� ��� �� ������
465
18a: 43 94 inc r4
466
18c: 01 c0 rjmp .+2 ; 0x190 <__vector_9+0x40>
467
else
468
tick_volt = 0; // ���� ������� ��������������� - �����
469
18e: 44 24 eor r4, r4
470
471
adch_volt = adch_val;
472
190: 38 2e mov r3, r24
473
474
#ifdef THEMPERATURE_CONTROL
475
}
476
InvMeasureMode();
477
192: 81 e0 ldi r24, 0x01 ; 1
478
194: 80 27 eor r24, r16
479
196: 08 2f mov r16, r24
480
#endif
481
482
#ifdef THEMPERATURE_CONTROL
483
if((tick_volt > 0x40)|(tick_temp > 0x10)) // �������� ��� ������ � ��������
484
198: 90 e1 ldi r25, 0x10 ; 16
485
19a: 99 15 cp r25, r9
486
19c: 18 f0 brcs .+6 ; 0x1a4 <__vector_9+0x54>
487
19e: 90 e4 ldi r25, 0x40 ; 64
488
1a0: 94 15 cp r25, r4
489
1a2: 48 f4 brcc .+18 ; 0x1b6 <__vector_9+0x66>
490
#else
491
if(tick_volt > 0x80)
492
#endif
493
{
494
tick_volt = 0; // ��������, ����� ���������� �� � ����� �������, � ���������
495
1a4: 44 24 eor r4, r4
496
#ifdef THEMPERATURE_CONTROL
497
tick_temp = 0;
498
1a6: 99 24 eor r9, r9
499
#ifndef REVERSE_SW
500
current_mode++; // ��������� �������
501
if (current_mode == (MAX_MODES+1))
502
SetOffMode();
503
#else
504
current_mode--; // ����� �������� �������
505
1a8: 95 2d mov r25, r5
506
1aa: 91 50 subi r25, 0x01 ; 1
507
1ac: 59 2e mov r5, r25
508
if (current_mode == 0xFF)
509
1ae: 9f 3f cpi r25, 0xFF ; 255
510
1b0: 11 f4 brne .+4 ; 0x1b6 <__vector_9+0x66>
511
SetOffMode();
512
1b2: 08 2f mov r16, r24
513
1b4: 04 60 ori r16, 0x04 ; 4
514
#endif
515
}
516
}
517
1b6: 9f 91 pop r25
518
1b8: 8f 91 pop r24
519
1ba: 0f 90 pop r0
520
1bc: 0f be out 0x3f, r0 ; 63
521
1be: 0f 90 pop r0
522
1c0: 1f 90 pop r1
523
1c2: 18 95 reti
524
525
000001c4 <input_mode>:
526
}
527
#endif
528
529
static NOINLINE void input_mode(void)
530
{
531
all_off();
532
1c4: 50 df rcall .-352 ; 0x66 <all_off>
533
delay_ms(150);
534
1c6: 86 e9 ldi r24, 0x96 ; 150
535
1c8: 7b df rcall .-266 ; 0xc0 <delay_ms>
536
mode_saver = 0xAA;
537
1ca: 8a ea ldi r24, 0xAA ; 170
538
1cc: 68 2e mov r6, r24
539
#ifdef MODE_SET_LEVEL
540
#if MAX_MODES == 3
541
current_mode = ((current_mode - 1) & 0x03); // ������������ ������� �������
542
1ce: 85 2d mov r24, r5
543
1d0: 81 50 subi r24, 0x01 ; 1
544
1d2: 93 e0 ldi r25, 0x03 ; 3
545
1d4: 59 2e mov r5, r25
546
1d6: 58 22 and r5, r24
547
current_mode--;
548
if (current_mode == 0xFF)
549
current_mode = MAX_MODES;
550
#endif
551
#endif
552
}
553
1d8: 08 95 ret
554
555
000001da <main>:
556
}
557
558
559
OS_MAIN int main(void)
560
{
561
cli(); //disable interrupts
562
1da: f8 94 cli
563
ClearFlags();
564
1dc: 00 e0 ldi r16, 0x00 ; 0
565
{
566
if((MCUSR & (1<<EXTRF)) == 0) SetNewMode();
567
MCUSR=0;
568
}
569
#else
570
if (mode_switcher == 0xAA)
571
1de: 8a ea ldi r24, 0xAA ; 170
572
1e0: d8 16 cp r13, r24
573
1e2: 09 f4 brne .+2 ; 0x1e6 <main+0xc>
574
SetNewMode();
575
1e4: 02 e0 ldi r16, 0x02 ; 2
576
mode_switcher = 0xAA;
577
1e6: 5a ea ldi r21, 0xAA ; 170
578
1e8: d5 2e mov r13, r21
579
#endif
580
581
wdt_reset();
582
1ea: a8 95 wdr
583
tick_volt = 0;
584
1ec: 44 24 eor r4, r4
585
#ifdef THEMPERATURE_CONTROL
586
tick_temp = 0;
587
1ee: 99 24 eor r9, r9
588
SetMeasureVolt();
589
1f0: 0e 7f andi r16, 0xFE ; 254
590
}
591
592
593
static INLINE void initialize(void)
594
{
595
CLKPR = 0x80;
596
1f2: 90 e8 ldi r25, 0x80 ; 128
597
1f4: 96 bd out 0x26, r25 ; 38
598
CLKPR = 0x01; // ������������� �������� �������� �������
599
1f6: 81 e0 ldi r24, 0x01 ; 1
600
1f8: 86 bd out 0x26, r24 ; 38
601
602
// Port B initialization
603
PORTB = PB_CONFIG; // PB4, PB5 ����������� � +
604
1fa: 20 e3 ldi r18, 0x30 ; 48
605
1fc: 28 bb out 0x18, r18 ; 24
606
DDRB = DDRB_CONFIG; // PB0, PB1, PB3 - ������
607
1fe: 2b e0 ldi r18, 0x0B ; 11
608
200: 27 bb out 0x17, r18 ; 23
609
610
ACSR = 0x80; // 1000 0000 Analog Comparator Disable
611
202: 98 b9 out 0x08, r25 ; 8
612
DIDR0 = 0x14;
613
204: 94 e1 ldi r25, 0x14 ; 20
614
206: 94 bb out 0x14, r25 ; 20
615
616
PRR = 0;
617
208: 15 bc out 0x25, r1 ; 37
618
619
ADMUX = 0x61; // 0110 0001 Internal Voltage Reference (1.1V) , ADC1 , 01 PB2 - ������� (��� 10 PB4 - �����������)
620
20a: 91 e6 ldi r25, 0x61 ; 97
621
20c: 97 b9 out 0x07, r25 ; 7
622
ADCSRA = 0xA7; // 0xA7 - 1010 1111 ��������, �� �� ����������, ADC Interrupt Enable, Division Factor = 128
623
20e: 97 ea ldi r25, 0xA7 ; 167
624
210: 96 b9 out 0x06, r25 ; 6
625
ADCSRB = 0;
626
212: 13 b8 out 0x03, r1 ; 3
627
628
//- �������� ���
629
TCNT0 = 0x00;
630
214: 12 be out 0x32, r1 ; 50
631
OCR0A = 0x00;
632
216: 16 be out 0x36, r1 ; 54
633
TCCR0B = 0x01;
634
218: 83 bf out 0x33, r24 ; 51
635
TCCR0A = 0x83;
636
21a: 83 e8 ldi r24, 0x83 ; 131
637
21c: 8f bd out 0x2f, r24 ; 47
638
639
MCUCR = 0x20; // IdleMode
640
21e: 80 e2 ldi r24, 0x20 ; 32
641
220: 85 bf out 0x35, r24 ; 53
642
TIMSK0 = 0x00; // timer interrupt sources
643
222: 19 be out 0x39, r1 ; 57
644
GIMSK = 0x00; // interrupt sources
645
224: 1b be out 0x3b, r1 ; 59
646
647
sei(); // enable interrupts
648
226: 78 94 sei
649
#endif
650
#endif
651
652
static INLINE void start_wdt(void)
653
{
654
wdt_reset();
655
228: a8 95 wdr
656
WDTCR = (_BV(WDCE) | _BV(WDE));
657
22a: 88 e1 ldi r24, 0x18 ; 24
658
22c: 81 bd out 0x21, r24 ; 33
659
WDTCR = (_BV(WDTIE) | WDTO_250MS);
660
22e: 84 e4 ldi r24, 0x44 ; 68
661
230: 81 bd out 0x21, r24 ; 33
662
663
initialize();
664
start_wdt();
665
666
#ifdef THEMPERATURE_CONTROL
667
uint8_t temporary = ReadEEPROMByte(CFG_CALIBRATE);
668
232: 8d e3 ldi r24, 0x3D ; 61
669
234: 12 df rcall .-476 ; 0x5a <ReadEEPROMByte>
670
236: c8 2f mov r28, r24
671
if(!temporary)
672
238: 88 23 and r24, r24
673
23a: 69 f4 brne .+26 ; 0x256 <main+0x7c>
674
{
675
if(IsNewMode()) // ���� �������� ���� ���������� ����� �������� ��
676
23c: 01 ff sbrs r16, 1
677
23e: 08 c0 rjmp .+16 ; 0x250 <main+0x76>
678
{
679
if(calibrator11 == calibrator10) // � �����?
680
240: 6b 2d mov r22, r11
681
242: ba 14 cp r11, r10
682
244: 41 f4 brne .+16 ; 0x256 <main+0x7c>
683
{
684
#ifdef REVERSE_SW
685
WriteEEPROMByte(CFG_CALIBRATE, calibrator10 - MAX_MODES); //
686
246: 63 50 subi r22, 0x03 ; 3
687
248: 8d e3 ldi r24, 0x3D ; 61
688
24a: fe de rcall .-516 ; 0x48 <WriteEEPROMByte>
689
WriteEEPROMByte(CFG_CALIBRATE, calibrator10); //
690
#endif
691
#ifndef FLASH_OFF
692
flash(20);
693
#endif
694
pwr_down();
695
24c: 15 df rcall .-470 ; 0x78 <pwr_down>
696
24e: 03 c0 rjmp .+6 ; 0x256 <main+0x7c>
697
}
698
}
699
else
700
WriteEEPROMByte(CFG_CALIBRATE, 0xFF); // � ���� ���������� ������� - ��������� ��
701
250: 8d e3 ldi r24, 0x3D ; 61
702
252: 6f ef ldi r22, 0xFF ; 255
703
254: f9 de rcall .-526 ; 0x48 <WriteEEPROMByte>
704
}
705
MAX_THEMP = temporary;
706
256: cc 2e mov r12, r28
707
if(MAX_THEMP == 0xFF) MAX_THEMP = 0; // �� ������, ����...
708
258: cf 3f cpi r28, 0xFF ; 255
709
25a: 09 f4 brne .+2 ; 0x25e <main+0x84>
710
25c: cc 24 eor r12, r12
711
#endif
712
713
#ifdef RAMPING
714
uint8_t ramping = ReadEEPROMByte(CFG_RAMPING);
715
25e: 8f e3 ldi r24, 0x3F ; 63
716
260: fc de rcall .-520 ; 0x5a <ReadEEPROMByte>
717
if (!ramping)
718
262: 88 23 and r24, r24
719
264: 69 f4 brne .+26 ; 0x280 <main+0xa6>
720
{
721
if(IsNewMode()) // ���� �������� ���� ���������� ����� ��������
722
{
723
WriteEEPROMByte(CFG_RAMPING, ramping_reg);
724
266: 8f e3 ldi r24, 0x3F ; 63
725
726
#ifdef RAMPING
727
uint8_t ramping = ReadEEPROMByte(CFG_RAMPING);
728
if (!ramping)
729
{
730
if(IsNewMode()) // ���� �������� ���� ���������� ����� ��������
731
268: 01 ff sbrs r16, 1
732
26a: 07 c0 rjmp .+14 ; 0x27a <main+0xa0>
733
{
734
WriteEEPROMByte(CFG_RAMPING, ramping_reg);
735
26c: 67 2d mov r22, r7
736
26e: ec de rcall .-552 ; 0x48 <WriteEEPROMByte>
737
WriteEEPROMByte(CFG_MOONMODE, 0x00);
738
270: 8b e3 ldi r24, 0x3B ; 59
739
272: 60 e0 ldi r22, 0x00 ; 0
740
274: e9 de rcall .-558 ; 0x48 <WriteEEPROMByte>
741
ClearNewMode();
742
276: 0d 7f andi r16, 0xFD ; 253
743
278: 04 c0 rjmp .+8 ; 0x282 <main+0xa8>
744
}
745
else
746
WriteEEPROMByte(CFG_RAMPING, 0xFF);
747
27a: 6f ef ldi r22, 0xFF ; 255
748
27c: e5 de rcall .-566 ; 0x48 <WriteEEPROMByte>
749
27e: 01 c0 rjmp .+2 ; 0x282 <main+0xa8>
750
}
751
else
752
ramping_reg = ramping;
753
280: 78 2e mov r7, r24
754
755
if (ramping_reg == 0xFF)
756
282: 9f ef ldi r25, 0xFF ; 255
757
284: 79 16 cp r7, r25
758
286: 11 f4 brne .+4 ; 0x28c <main+0xb2>
759
#ifdef FREQMOON_OFF
760
ramping_reg = 2;
761
#else
762
ramping_reg = 1;
763
288: 77 24 eor r7, r7
764
28a: 73 94 inc r7
765
#else
766
ramping_reg = 1;
767
#endif
768
#endif
769
770
adc_on();
771
28c: 86 b1 in r24, 0x06 ; 6
772
28e: 88 64 ori r24, 0x48 ; 72
773
290: 86 b9 out 0x06, r24 ; 6
774
#endif
775
776
777
static INLINE void decode_mode(void)
778
{
779
if (IsNewMode()) // ���� �������� ����������,...
780
292: 01 ff sbrs r16, 1
781
294: 87 c0 rjmp .+270 ; 0x3a4 <main+0x1ca>
782
{
783
if(!short_off_counter)
784
296: 82 2d mov r24, r2
785
298: 22 20 and r2, r2
786
29a: 31 f4 brne .+12 ; 0x2a8 <main+0xce>
787
{
788
if(mode_saver == 0xAA)
789
29c: 9a ea ldi r25, 0xAA ; 170
790
29e: 69 16 cp r6, r25
791
2a0: 11 f4 brne .+4 ; 0x2a6 <main+0xcc>
792
{
793
mode_saver = 0;
794
2a2: 66 24 eor r6, r6
795
2a4: 01 c0 rjmp .+2 ; 0x2a8 <main+0xce>
796
// #else
797
// current_mode--;
798
#endif
799
}
800
else
801
current_mode++;
802
2a6: 53 94 inc r5
803
}
804
short_off_counter++;
805
2a8: 8f 5f subi r24, 0xFF ; 255
806
2aa: 28 2e mov r2, r24
807
if (short_off_counter == BATTERY_CLICKS) //... ��������� ������� ���� �������� ����������
808
2ac: 84 30 cpi r24, 0x04 ; 4
809
2ae: 31 f5 brne .+76 ; 0x2fc <main+0x122>
810
uint8_t switch_voltage [] = {U1, U2, U3, U4};
811
static INLINE void display_voltage(void)
812
{
813
uint8_t v_batt;
814
uint8_t i = 0;
815
input_mode();
816
2b0: 89 df rcall .-238 ; 0x1c4 <input_mode>
817
mode_saver = 0;
818
2b2: 66 24 eor r6, r6
819
v_batt = adch_volt;
820
2b4: e3 2c mov r14, r3
821
2b6: c2 e7 ldi r28, 0x72 ; 114
822
2b8: d0 e0 ldi r29, 0x00 ; 0
823
824
uint8_t switch_voltage [] = {U1, U2, U3, U4};
825
static INLINE void display_voltage(void)
826
{
827
uint8_t v_batt;
828
uint8_t i = 0;
829
2ba: 10 e0 ldi r17, 0x00 ; 0
830
input_mode();
831
mode_saver = 0;
832
v_batt = adch_volt;
833
while(1)
834
{
835
OCR0A = 0x80;
836
2bc: 40 e8 ldi r20, 0x80 ; 128
837
2be: f4 2e mov r15, r20
838
2c0: f6 be out 0x36, r15 ; 54
839
delay_ms(75);
840
2c2: 8b e4 ldi r24, 0x4B ; 75
841
2c4: fd de rcall .-518 ; 0xc0 <delay_ms>
842
OCR0A = 0x00;
843
2c6: 16 be out 0x36, r1 ; 54
844
delay_ms(100);
845
2c8: 84 e6 ldi r24, 0x64 ; 100
846
2ca: fa de rcall .-524 ; 0xc0 <delay_ms>
847
if(v_batt < switch_voltage[i])
848
2cc: 89 91 ld r24, Y+
849
2ce: e8 16 cp r14, r24
850
2d0: 18 f0 brcs .+6 ; 0x2d8 <main+0xfe>
851
break;
852
if(++i >= 5)
853
2d2: 1f 5f subi r17, 0xFF ; 255
854
2d4: 15 30 cpi r17, 0x05 ; 5
855
2d6: a1 f7 brne .-24 ; 0x2c0 <main+0xe6>
856
break;
857
}
858
delay_ms(100);
859
2d8: 84 e6 ldi r24, 0x64 ; 100
860
2da: f2 de rcall .-540 ; 0xc0 <delay_ms>
861
862
#ifdef THEMPERATURE_CONTROL
863
i = ReadEEPROMByte(CFG_CALIBRATE);
864
2dc: 8d e3 ldi r24, 0x3D ; 61
865
2de: bd de rcall .-646 ; 0x5a <ReadEEPROMByte>
866
if((!i) || (i == 0xFF)) // ���� ������������� �������� - ������
867
2e0: 81 50 subi r24, 0x01 ; 1
868
2e2: 8e 3f cpi r24, 0xFE ; 254
869
2e4: 08 f4 brcc .+2 ; 0x2e8 <main+0x10e>
870
2e6: 64 c0 rjmp .+200 ; 0x3b0 <main+0x1d6>
871
static INLINE void flash(uint8_t i)
872
#else
873
static NOINLINE void flash(uint8_t i)
874
#endif
875
{
876
all_off();
877
2e8: be de rcall .-644 ; 0x66 <all_off>
878
2ea: ca e0 ldi r28, 0x0A ; 10
879
do{ delay_ms(20);
880
2ec: 84 e1 ldi r24, 0x14 ; 20
881
2ee: e8 de rcall .-560 ; 0xc0 <delay_ms>
882
OCR0A ^= 0xFF;
883
2f0: 86 b7 in r24, 0x36 ; 54
884
2f2: 80 95 com r24
885
2f4: 86 bf out 0x36, r24 ; 54
886
2f6: c1 50 subi r28, 0x01 ; 1
887
}while(--i);
888
2f8: c9 f7 brne .-14 ; 0x2ec <main+0x112>
889
2fa: 5a c0 rjmp .+180 ; 0x3b0 <main+0x1d6>
890
if (short_off_counter == BATTERY_CLICKS) //... ��������� ������� ���� �������� ����������
891
{
892
display_voltage();
893
}
894
#ifdef MODELINECHG
895
else if (short_off_counter == MODELINECHG_CLICKS)
896
2fc: 83 30 cpi r24, 0x03 ; 3
897
2fe: 19 f4 brne .+6 ; 0x306 <main+0x12c>
898
899
900
static INLINE void mode_line_chg(void) // �������� MODELINECHG
901
#ifdef ONECLICKMOON
902
{
903
input_mode();
904
300: 61 df rcall .-318 ; 0x1c4 <input_mode>
905
WriteEEPROMByte(CFG_MOONMODE, 0x00);
906
302: 8b e3 ldi r24, 0x3B ; 59
907
304: 07 c0 rjmp .+14 ; 0x314 <main+0x13a>
908
else if (short_off_counter == MODELINECHG_CLICKS)
909
mode_line_chg();
910
#endif
911
912
#ifdef THEMPERATURE_CONTROL
913
else if (short_off_counter == CALIBRATE_CLICKS)
914
306: 8c 30 cpi r24, 0x0C ; 12
915
308: 41 f4 brne .+16 ; 0x31a <main+0x140>
916
917
918
#ifdef THEMPERATURE_CONTROL
919
static INLINE void calibrate(void) // ���������� �������������
920
{
921
input_mode();
922
30a: 5c df rcall .-328 ; 0x1c4 <input_mode>
923
flash(20);
924
#endif
925
#ifndef REVERSE_SW
926
current_mode = 0;
927
#else
928
current_mode = MAX_MODES;
929
30c: 33 e0 ldi r19, 0x03 ; 3
930
30e: 53 2e mov r5, r19
931
#endif
932
MAX_THEMP = 0; // �������� ���������� �.�. ��������� ��
933
310: cc 24 eor r12, r12
934
WriteEEPROMByte(CFG_CALIBRATE, 0); // �������� � eeprom
935
312: 8d e3 ldi r24, 0x3D ; 61
936
314: 60 e0 ldi r22, 0x00 ; 0
937
316: 98 de rcall .-720 ; 0x48 <WriteEEPROMByte>
938
318: 4b c0 rjmp .+150 ; 0x3b0 <main+0x1d6>
939
else if (short_off_counter == CALIBRATE_CLICKS)
940
calibrate();
941
#endif
942
943
#ifdef RAMPING
944
else if (short_off_counter == RAMPING_CLICKS)
945
31a: 88 30 cpi r24, 0x08 ; 8
946
31c: 89 f4 brne .+34 ; 0x340 <main+0x166>
947
948
#ifdef RAMPING
949
static INLINE void ramping_loop(void)
950
{
951
uint8_t k;
952
input_mode();
953
31e: 52 df rcall .-348 ; 0x1c4 <input_mode>
954
WriteEEPROMByte(CFG_RAMPING, 0); // �������� � eeprom
955
320: 8f e3 ldi r24, 0x3F ; 63
956
322: 60 e0 ldi r22, 0x00 ; 0
957
324: 91 de rcall .-734 ; 0x48 <WriteEEPROMByte>
958
#ifndef FREQMOON_OFF
959
cpu_div();
960
326: a3 de rcall .-698 ; 0x6e <cpu_div>
961
{
962
#ifdef FREQMOON_OFF
963
ramping_reg = 2;
964
k = 6;
965
#else
966
ramping_reg = 1;
967
328: 77 24 eor r7, r7
968
32a: 73 94 inc r7
969
32c: c7 e0 ldi r28, 0x07 ; 7
970
k = 7;
971
#endif
972
973
do
974
{
975
OCR0A = ramping_reg;
976
32e: 76 be out 0x36, r7 ; 54
977
#ifdef FREQMOON_OFF
978
delay_ms(250);
979
#else
980
delay_ms(125);
981
330: 8d e7 ldi r24, 0x7D ; 125
982
332: c6 de rcall .-628 ; 0xc0 <delay_ms>
983
#endif
984
if (IsOffMode()) //��� �������� �������
985
334: 02 fd sbrc r16, 2
986
pwr_down();
987
336: a0 de rcall .-704 ; 0x78 <pwr_down>
988
ramping_reg = (ramping_reg<<1);
989
338: 77 0c add r7, r7
990
33a: c1 50 subi r28, 0x01 ; 1
991
}while(--k);
992
33c: c1 f7 brne .-16 ; 0x32e <main+0x154>
993
33e: f4 cf rjmp .-24 ; 0x328 <main+0x14e>
994
else if (short_off_counter == PULSE_MODE_CLICKS)
995
pulse();
996
#endif
997
998
#ifdef SLOW_PULSE_MODE
999
else if (short_off_counter == SLOW_PULSE_MODE_CLICKS)
1000
340: 86 30 cpi r24, 0x06 ; 6
1001
342: 41 f4 brne .+16 ; 0x354 <main+0x17a>
1002
1003
1004
#ifdef SLOW_PULSE_MODE
1005
static INLINE void s_pulse(void) // ���� ��������� �����, �������������
1006
{
1007
input_mode();
1008
344: 3f df rcall .-386 ; 0x1c4 <input_mode>
1009
#ifndef MODE_SET_LEVEL
1010
current_mode = SlowPulseMod;
1011
#endif
1012
while(1)
1013
{
1014
set_mode(current_mode);
1015
346: 85 2d mov r24, r5
1016
348: a3 de rcall .-698 ; 0x90 <set_mode>
1017
delay_ms(PULSE_ON);
1018
34a: 8d e7 ldi r24, 0x7D ; 125
1019
34c: b9 de rcall .-654 ; 0xc0 <delay_ms>
1020
all_off();
1021
34e: 8b de rcall .-746 ; 0x66 <all_off>
1022
delay_sec(PULSE_OFF);
1023
350: c0 de rcall .-640 ; 0xd2 <delay_sec.constprop.0>
1024
352: f9 cf rjmp .-14 ; 0x346 <main+0x16c>
1025
else if (short_off_counter == VELO_STROBE_CLICKS)
1026
velo_pulse();
1027
#endif
1028
1029
#ifdef POLICE_MODE
1030
else if (short_off_counter == POLICE_MODE_CLICKS)
1031
354: 85 30 cpi r24, 0x05 ; 5
1032
356: 81 f4 brne .+32 ; 0x378 <main+0x19e>
1033
1034
#ifdef POLICE_MODE
1035
static INLINE void police_pulse(void)
1036
{
1037
uint8_t k;
1038
input_mode();
1039
358: 35 df rcall .-406 ; 0x1c4 <input_mode>
1040
{
1041
#ifdef FREQMOON_OFF
1042
ramping_reg = 2;
1043
k = 6;
1044
#else
1045
ramping_reg = 1;
1046
35a: c4 e0 ldi r28, 0x04 ; 4
1047
#endif
1048
do{
1049
k = 4;
1050
do
1051
{
1052
set_mode(current_mode);
1053
35c: 85 2d mov r24, r5
1054
35e: 98 de rcall .-720 ; 0x90 <set_mode>
1055
delay_ms(5);
1056
360: 85 e0 ldi r24, 0x05 ; 5
1057
362: ae de rcall .-676 ; 0xc0 <delay_ms>
1058
all_off();
1059
364: 80 de rcall .-768 ; 0x66 <all_off>
1060
delay_ms(50);
1061
366: 82 e3 ldi r24, 0x32 ; 50
1062
368: ab de rcall .-682 ; 0xc0 <delay_ms>
1063
36a: c1 50 subi r28, 0x01 ; 1
1064
}while(--k);
1065
36c: b9 f7 brne .-18 ; 0x35c <main+0x182>
1066
delay_ms(200);
1067
36e: 88 ec ldi r24, 0xC8 ; 200
1068
370: a7 de rcall .-690 ; 0xc0 <delay_ms>
1069
delay_ms(140);
1070
372: 8c e8 ldi r24, 0x8C ; 140
1071
374: a5 de rcall .-694 ; 0xc0 <delay_ms>
1072
376: f1 cf rjmp .-30 ; 0x35a <main+0x180>
1073
else if (short_off_counter == POLICE_MODE_CLICKS)
1074
police_pulse();
1075
#endif
1076
1077
#ifdef SOS_MODE
1078
else if (short_off_counter == SOS_MODE_CLICKS)
1079
378: 87 30 cpi r24, 0x07 ; 7
1080
37a: d1 f4 brne .+52 ; 0x3b0 <main+0x1d6>
1081
#ifdef SOS_MODE
1082
uint8_t sos_delay [] = {255, 75, 75, 75, 75, 75, 225, 225, 75, 225, 75, 225, 225, 75, 75, 75, 75, 75};
1083
static INLINE void sos_pulse(void) // ��� ����� SOS
1084
{
1085
uint8_t k;
1086
input_mode();
1087
37c: 23 df rcall .-442 ; 0x1c4 <input_mode>
1088
37e: c1 e6 ldi r28, 0x61 ; 97
1089
380: d0 e0 ldi r29, 0x00 ; 0
1090
{
1091
#ifdef FREQMOON_OFF
1092
ramping_reg = 2;
1093
k = 6;
1094
#else
1095
ramping_reg = 1;
1096
382: 10 e0 ldi r17, 0x00 ; 0
1097
delay_ms(1);
1098
}
1099
}
1100
1101
1102
OS_MAIN int main(void)
1103
384: fe 01 movw r30, r28
1104
386: 31 97 sbiw r30, 0x01 ; 1
1105
while(1)
1106
{
1107
k = 0;
1108
do
1109
{
1110
delay_ms(sos_delay[k]);
1111
388: 80 81 ld r24, Z
1112
38a: 9a de rcall .-716 ; 0xc0 <delay_ms>
1113
k++;
1114
set_mode(current_mode);
1115
38c: 85 2d mov r24, r5
1116
38e: 80 de rcall .-768 ; 0x90 <set_mode>
1117
delay_ms(sos_delay[k]);
1118
390: 88 81 ld r24, Y
1119
392: 96 de rcall .-724 ; 0xc0 <delay_ms>
1120
k++;
1121
394: 1e 5f subi r17, 0xFE ; 254
1122
all_off();
1123
396: 67 de rcall .-818 ; 0x66 <all_off>
1124
398: 22 96 adiw r28, 0x02 ; 2
1125
}while(k != 18);
1126
39a: 12 31 cpi r17, 0x12 ; 18
1127
39c: 99 f7 brne .-26 ; 0x384 <main+0x1aa>
1128
delay_ms(255);
1129
39e: 8f ef ldi r24, 0xFF ; 255
1130
3a0: 8f de rcall .-738 ; 0xc0 <delay_ms>
1131
3a2: ed cf rjmp .-38 ; 0x37e <main+0x1a4>
1132
sos_pulse();
1133
#endif
1134
}
1135
else
1136
{
1137
short_off_counter = 0;
1138
3a4: 22 24 eor r2, r2
1139
1140
#ifndef NOMEM // ���� ���� ������� (��������) - ������ �����
1141
#ifdef WEAR_LEWELING
1142
current_mode = read_byte(CMODE_ADR);
1143
3a6: b5 de rcall .-662 ; 0x112 <read_byte.constprop.1>
1144
3a8: 58 2e mov r5, r24
1145
#else
1146
current_mode = ReadEEPROMByte(CFG_CURRENTMODE);
1147
#endif
1148
if (current_mode == 0xFF) // �� ������, ����...
1149
3aa: 8f 3f cpi r24, 0xFF ; 255
1150
3ac: 09 f4 brne .+2 ; 0x3b0 <main+0x1d6>
1151
current_mode = START_MODE;
1152
3ae: 55 24 eor r5, r5
1153
current_mode = START_MODE; // ��������, ����� ������ ���������� � ��������
1154
#endif
1155
}
1156
1157
#if MAX_MODES == 3
1158
current_mode = current_mode & 0x03; // ������������ ������� �������
1159
3b0: 83 e0 ldi r24, 0x03 ; 3
1160
3b2: 58 22 and r5, r24
1161
decode_mode();
1162
1163
#ifndef MODELINECHG
1164
std_loop();
1165
#else
1166
if (ReadEEPROMByte(CFG_MOONMODE) == 0xFF)
1167
3b4: 8b e3 ldi r24, 0x3B ; 59
1168
3b6: 51 de rcall .-862 ; 0x5a <ReadEEPROMByte>
1169
3b8: 8f 3f cpi r24, 0xFF ; 255
1170
3ba: 31 f0 breq .+12 ; 0x3c8 <main+0x1ee>
1171
std_loop();
1172
else
1173
#ifdef ONECLICKMOON
1174
if(IsNewMode()) // ���� �������� ���� ������� �� MODELINECHG
1175
3bc: 01 ff sbrs r16, 1
1176
3be: 05 c0 rjmp .+10 ; 0x3ca <main+0x1f0>
1177
{
1178
WriteEEPROMByte(CFG_MOONMODE, 0xFF);
1179
3c0: 8b e3 ldi r24, 0x3B ; 59
1180
3c2: 6f ef ldi r22, 0xFF ; 255
1181
3c4: 41 de rcall .-894 ; 0x48 <WriteEEPROMByte>
1182
#ifdef RST_LEV_MOON
1183
#ifdef REVERSE_SW // ����� ������� ����� ��������
1184
current_mode = 0;
1185
3c6: 55 24 eor r5, r5
1186
current_mode = MAX_MODES;
1187
#endif
1188
#else
1189
ClearNewMode();
1190
#endif
1191
std_loop();
1192
3c8: 8e de rcall .-740 ; 0xe6 <std_loop>
1193
}
1194
1195
1196
static INLINE void moon_loop(void) // MOONMODE
1197
{
1198
mode_saver = 0xAA;
1199
3ca: 2a ea ldi r18, 0xAA ; 170
1200
3cc: 62 2e mov r6, r18
1201
OCR0A = ramping_reg;
1202
3ce: 76 be out 0x36, r7 ; 54
1203
1204
#ifndef FREQMOON_OFF
1205
cpu_div();
1206
3d0: 4e de rcall .-868 ; 0x6e <cpu_div>
1207
#endif
1208
while(1)
1209
{
1210
sleep_cpu();
1211
3d2: 88 95 sleep
1212
if (IsOffMode())
1213
3d4: 02 fd sbrc r16, 2
1214
pwr_down();
1215
3d6: 50 de rcall .-864 ; 0x78 <pwr_down>
1216
delay_ms(1);
1217
3d8: 81 e0 ldi r24, 0x01 ; 1
1218
3da: 72 de rcall .-796 ; 0xc0 <delay_ms>
1219
3dc: fa cf rjmp .-12 ; 0x3d2 <main+0x1f8>
1220
1221
000003de <_exit>:
1222
3de: f8 94 cli
1223
1224
000003e0 <__stop_program>:
1225
3e0: ff cf rjmp .-2 ; 0x3e0 <__stop_program>
Loggerhead is a web-based interface for Breezy
Version: 2.0.1