MLABlibrarysvnkaklikMLAB_E8magsvn

Català-Valencià – Catalan中文 – Chinese (Simplified)中文 – Chinese (Traditional)Česky – CzechDansk – DanishNederlands – DutchEnglish – EnglishSuomi – FinnishFrançais – FrenchDeutsch – Germanעברית – Hebrewहिंदी – HindiMagyar – HungarianBahasa Indonesia – IndonesianItaliano – Italian日本語 – Japanese한국어 – KoreanМакедонски – Macedonianमराठी – MarathiNorsk – NorwegianPolski – PolishPortuguês – PortuguesePortuguês – Portuguese (Brazil)Русский – RussianSlovenčina – SlovakSlovenščina – SlovenianEspañol – SpanishSvenska – SwedishTürkçe – TurkishУкраїнська – UkrainianOëzbekcha – Uzbek

Compare Revisions

• This comparison shows the changes necessary to convert path

  → /programy/Atmel_C/AVRcam/AVRcam.lss @ 173

  → /programy/Atmel_C/AVRcam/AVRcam.lss @ 174

  ↔ Reverse comparison

• Compare Path:	Rev

  With Path:	Rev

Ignore whitespace Rev 173 → Rev 174

/programy/Atmel_C/AVRcam/AVRcam.lss
1,1747 → 1,1402
AVRcam.elf: file format elf32-avr
Sections:
Idx Name Size VMA LMA File off Algn
0 .noinit 00000030 00800300 00800300 00001162 2**0
ALLOC
1 .bss 00000274 00800070 00800070 00001162 2**0
ALLOC
2 .data 00000010 00800060 0000109e 00001152 2**0
CONTENTS, ALLOC, LOAD, DATA
3 .text 0000109e 00000000 00000000 000000b4 2**1
CONTENTS, ALLOC, LOAD, READONLY, CODE
4 .eeprom 00000000 00810000 00810000 00001162 2**0
CONTENTS
5 .stab 00003f30 00000000 00000000 00001164 2**2
CONTENTS, READONLY, DEBUGGING
6 .stabstr 0000181e 00000000 00000000 00005094 2**0
CONTENTS, READONLY, DEBUGGING
Disassembly of section .text:
00000000 <__vectors>:
0: 63 c0 rjmp .+198 ; 0xc8
2: ea c7 rjmp .+4052 ; 0xfd8
4: ea c7 rjmp .+4052 ; 0xfda
6: 7a c0 rjmp .+244 ; 0xfc
8: 79 c0 rjmp .+242 ; 0xfc
a: 78 c0 rjmp .+240 ; 0xfc
c: 77 c0 rjmp .+238 ; 0xfc
e: 76 c0 rjmp .+236 ; 0xfc
10: e5 c7 rjmp .+4042 ; 0xfdc
12: 74 c0 rjmp .+232 ; 0xfc
14: 73 c0 rjmp .+230 ; 0xfc
16: a8 c5 rjmp .+2896 ; 0xb68
18: 71 c0 rjmp .+226 ; 0xfc
1a: 70 c0 rjmp .+224 ; 0xfc
1c: 6f c0 rjmp .+222 ; 0xfc
1e: 6e c0 rjmp .+220 ; 0xfc
20: 6d c0 rjmp .+218 ; 0xfc
22: 13 c6 rjmp .+3110 ; 0xc4a
24: 6b c0 rjmp .+214 ; 0xfc
00000026 <__ctors_end>:
26: 2a c6 rjmp .+3156 ; 0xc7c
28: 93 c6 rjmp .+3366 ; 0xd50
2a: 92 c6 rjmp .+3364 ; 0xd50
2c: 91 c6 rjmp .+3362 ; 0xd50
2e: 90 c6 rjmp .+3360 ; 0xd50
30: 8f c6 rjmp .+3358 ; 0xd50
32: 8e c6 rjmp .+3356 ; 0xd50
34: 8d c6 rjmp .+3354 ; 0xd50
36: 22 c6 rjmp .+3140 ; 0xc7c
38: 8b c6 rjmp .+3350 ; 0xd50
3a: 8a c6 rjmp .+3348 ; 0xd50
3c: 89 c6 rjmp .+3346 ; 0xd50
3e: 88 c6 rjmp .+3344 ; 0xd50
40: 87 c6 rjmp .+3342 ; 0xd50
42: 86 c6 rjmp .+3340 ; 0xd50
44: 85 c6 rjmp .+3338 ; 0xd50
46: 2a c6 rjmp .+3156 ; 0xc9c
48: 83 c6 rjmp .+3334 ; 0xd50
4a: 82 c6 rjmp .+3332 ; 0xd50
4c: 81 c6 rjmp .+3330 ; 0xd50
4e: 80 c6 rjmp .+3328 ; 0xd50
50: 7f c6 rjmp .+3326 ; 0xd50
52: 7e c6 rjmp .+3324 ; 0xd50
54: 7d c6 rjmp .+3322 ; 0xd50
56: 25 c6 rjmp .+3146 ; 0xca2
58: 7b c6 rjmp .+3318 ; 0xd50
5a: 7a c6 rjmp .+3316 ; 0xd50
5c: 79 c6 rjmp .+3314 ; 0xd50
5e: 78 c6 rjmp .+3312 ; 0xd50
60: 77 c6 rjmp .+3310 ; 0xd50
62: 76 c6 rjmp .+3308 ; 0xd50
64: 75 c6 rjmp .+3306 ; 0xd50
66: 25 c6 rjmp .+3146 ; 0xcb2
68: 73 c6 rjmp .+3302 ; 0xd50
6a: 72 c6 rjmp .+3300 ; 0xd50
6c: 71 c6 rjmp .+3298 ; 0xd50
6e: 70 c6 rjmp .+3296 ; 0xd50
70: 6f c6 rjmp .+3294 ; 0xd50
72: 6e c6 rjmp .+3292 ; 0xd50
74: 6d c6 rjmp .+3290 ; 0xd50
76: 64 c6 rjmp .+3272 ; 0xd40
78: 6b c6 rjmp .+3286 ; 0xd50
7a: 6a c6 rjmp .+3284 ; 0xd50
7c: 69 c6 rjmp .+3282 ; 0xd50
7e: 68 c6 rjmp .+3280 ; 0xd50
80: 67 c6 rjmp .+3278 ; 0xd50
82: 66 c6 rjmp .+3276 ; 0xd50
84: 65 c6 rjmp .+3274 ; 0xd50
86: 64 c6 rjmp .+3272 ; 0xd50
88: 63 c6 rjmp .+3270 ; 0xd50
8a: 62 c6 rjmp .+3268 ; 0xd50
8c: 61 c6 rjmp .+3266 ; 0xd50
8e: 60 c6 rjmp .+3264 ; 0xd50
90: 5f c6 rjmp .+3262 ; 0xd50
92: 5e c6 rjmp .+3260 ; 0xd50
94: 5d c6 rjmp .+3258 ; 0xd50
96: 23 c6 rjmp .+3142 ; 0xcde
98: 5b c6 rjmp .+3254 ; 0xd50
9a: 5a c6 rjmp .+3252 ; 0xd50
9c: 59 c6 rjmp .+3250 ; 0xd50
9e: 58 c6 rjmp .+3248 ; 0xd50
a0: 57 c6 rjmp .+3246 ; 0xd50
a2: 56 c6 rjmp .+3244 ; 0xd50
a4: 55 c6 rjmp .+3242 ; 0xd50
a6: fd c5 rjmp .+3066 ; 0xca2
a8: 53 c6 rjmp .+3238 ; 0xd50
aa: 52 c6 rjmp .+3236 ; 0xd50
ac: 51 c6 rjmp .+3234 ; 0xd50
ae: 50 c6 rjmp .+3232 ; 0xd50
b0: 4f c6 rjmp .+3230 ; 0xd50
b2: 4e c6 rjmp .+3228 ; 0xd50
b4: 4d c6 rjmp .+3226 ; 0xd50
b6: 1f c6 rjmp .+3134 ; 0xcf6
b8: 4b c6 rjmp .+3222 ; 0xd50
ba: 4a c6 rjmp .+3220 ; 0xd50
bc: 49 c6 rjmp .+3218 ; 0xd50
be: 48 c6 rjmp .+3216 ; 0xd50
c0: 47 c6 rjmp .+3214 ; 0xd50
c2: 46 c6 rjmp .+3212 ; 0xd50
c4: 45 c6 rjmp .+3210 ; 0xd50
c6: 36 c6 rjmp .+3180 ; 0xd34
000000c8 <__init>:
c8: 11 24 eor r1, r1
ca: 1f be out 0x3f, r1 ; 63
cc: cf e5 ldi r28, 0x5F ; 95
ce: d4 e0 ldi r29, 0x04 ; 4
d0: de bf out 0x3e, r29 ; 62
d2: cd bf out 0x3d, r28 ; 61
000000d4 <__do_copy_data>:
d4: 10 e0 ldi r17, 0x00 ; 0
d6: a0 e6 ldi r26, 0x60 ; 96
d8: b0 e0 ldi r27, 0x00 ; 0
da: ee e9 ldi r30, 0x9E ; 158
dc: f0 e1 ldi r31, 0x10 ; 16
de: 02 c0 rjmp .+4 ; 0xe4
000000e0 <.do_copy_data_loop>:
e0: 05 90 lpm r0, Z+
e2: 0d 92 st X+, r0
000000e4 <.do_copy_data_start>:
e4: a0 37 cpi r26, 0x70 ; 112
e6: b1 07 cpc r27, r17
e8: d9 f7 brne .-10 ; 0xe0
000000ea <__do_clear_bss>:
ea: 12 e0 ldi r17, 0x02 ; 2
ec: a0 e7 ldi r26, 0x70 ; 112
ee: b0 e0 ldi r27, 0x00 ; 0
f0: 01 c0 rjmp .+2 ; 0xf4
000000f2 <.do_clear_bss_loop>:
f2: 1d 92 st X+, r1
000000f4 <.do_clear_bss_start>:
f4: a4 3e cpi r26, 0xE4 ; 228
f6: b1 07 cpc r27, r17
f8: e1 f7 brne .-8 ; 0xf2
fa: 31 c0 rjmp .+98 ; 0x15e
000000fc <__bad_interrupt>:
fc: 76 c7 rjmp .+3820 ; 0xfea
000000fe <CamInt_init>:
#endif
/* set up the mega8 ports that will be interfacing
with the camera */
CAM_CONTROL_PORT_DIR |= (1<<CAM_RESET_LINE); /* cam reset is output */
fe: 8f 9a sbi 0x11, 7 ; 17
CAM_CONTROL_PORT_DIR |= 0x80; /* set just the MSB as an output */
100: 8f 9a sbi 0x11, 7 ; 17
CAM_CONTROL_PORT_DIR &= 0xFB; /* make sure bit2 is clear (input) */
102: 8a 98 cbi 0x11, 2 ; 17
CAM_CONTROL_PORT &= 0x7F; /* set reset line low */
104: 97 98 cbi 0x12, 7 ; 18
CAM_G_BUS_DIR &= 0xF0; /* 4-bit G bus all inputs */
106: 90 ef ldi r25, 0xF0 ; 240
108: 87 b3 in r24, 0x17 ; 23
10a: 89 23 and r24, r25
10c: 87 bb out 0x17, r24 ; 23
CAM_G_BUS_DIR |= 0xF0; /* disable the pull-up on PB4 and PB5 */
10e: 87 b3 in r24, 0x17 ; 23
110: 89 2b or r24, r25
112: 87 bb out 0x17, r24 ; 23
CAM_RB_BUS_DIR &= 0xF0; /* 4-bit RB bus all inputs */
114: 84 b3 in r24, 0x14 ; 20
116: 89 23 and r24, r25
118: 84 bb out 0x14, r24 ; 20
/* ensure that timer1 is disabled to start...eventually, when PCLK needs
to feed timer1 through the external counter, it will be enabled on an
"as needed" basis...*/
TCCR1B &= ~( (1<<CS12)|(1<<CS11)|(1<<CS10) );
11a: 8e b5 in r24, 0x2e ; 46
11c: 88 7f andi r24, 0xF8 ; 248
11e: 8e bd out 0x2e, r24 ; 46
/* we'll turn on the interrupt after we assign the initial TCNT value */
/* set up External Interrupt1 to interrupt us on rising edges (HREF)...
this is needed to indicate when the first pixel of each line is about to start, so
we can synch up with it...this interrupt will be disabled once HREF goes high */
MCUCR |= (1<<ISC11) | (1<<ISC10); /* rising edge interrupt */
120: 85 b7 in r24, 0x35 ; 53
122: 8c 60 ori r24, 0x0C ; 12
124: 85 bf out 0x35, r24 ; 53
/* the interrupt will be enabled when we are ready to detect the rising edge of
HREF...its now primed and ready to go */
/* set up External Interrupt0 to interrupt us on rising edges (VSYNC) */
MCUCR |= (1<<ISC01) | (1<<ISC00); /* rising edge interrupt */
126: 85 b7 in r24, 0x35 ; 53
128: 83 60 ori r24, 0x03 ; 3
12a: 85 bf out 0x35, r24 ; 53
GICR |= (1<<INT0); /* interrupt request enabled */
12c: 8b b7 in r24, 0x3b ; 59
12e: 80 64 ori r24, 0x40 ; 64
130: 8b bf out 0x3b, r24 ; 59
/* set up TimerO to count and be clocked from an external pulse source
(HREF) on falling edges...eventually, we need to enable the interrupt
for this! FIX THIS */
TCCR0 = (1<<CS02)|(1<<CS01)|(0<<CS00);
132: 86 e0 ldi r24, 0x06 ; 6
134: 83 bf out 0x33, r24 ; 51
/* setting up the PCLK counter with Timer1 will be done right after
we start receiving pixels in each line...we sacrifice the first pixel
in each line, but we'll account for it...*/
/* set up the mega8 so that its sleep mode puts it in an IDLE sleep
mode, where it can wake up as fast as possible */
set_sleep_mode(SLEEP_MODE_IDLE);
136: 85 b7 in r24, 0x35 ; 53
138: 8f 78 andi r24, 0x8F ; 143
13a: 85 bf out 0x35, r24 ; 53
/* umm....we need to actually enable the sleep mode...*/
MCUCR |= 0x80;
13c: 85 b7 in r24, 0x35 ; 53
13e: 80 68 ori r24, 0x80 ; 128
140: 85 bf out 0x35, r24 ; 53
/* initialize the memLookup table */
memset(colorMap,0x00,NUM_ELEMENTS_IN_COLOR_MAP);
142: 80 e0 ldi r24, 0x00 ; 0
144: 93 e0 ldi r25, 0x03 ; 3
146: 20 e3 ldi r18, 0x30 ; 48
148: fc 01 movw r30, r24
14a: 11 92 st Z+, r1
14c: 2a 95 dec r18
14e: e9 f7 brne .-6 ; 0x14a
/* read the color map out of EEPROM */
eeprom_read_block(colorMap, (unsigned char*)0x01,NUM_ELEMENTS_IN_COLOR_MAP);
150: 40 e3 ldi r20, 0x30 ; 48
152: 50 e0 ldi r21, 0x00 ; 0
154: 61 e0 ldi r22, 0x01 ; 1
156: 70 e0 ldi r23, 0x00 ; 0
158: 7d d7 rcall .+3834 ; 0x1054
#if OUTPUT_INITIAL_COLOR_MAP
UIMgr_txBuffer("\r\n",2);
for (i=0; i<NUM_ELEMENTS_IN_COLOR_MAP; i++)
{
memset(asciiBuffer,0x00,5);
itoa(colorMap[i],asciiBuffer,10);
UIMgr_txBuffer(asciiBuffer,3);
UIMgr_txBuffer(" ",1);
if (i==15 || i == 31)
{
/* break up the output */
UIMgr_txBuffer("\r\n",2);
}
}
#endif
#ifndef NO_CRYSTAL
CamInt_resetCam();
#endif
}
15a: 08 95 ret
0000015c <CamInt_resetCam>:
/***********************************************************
Function Name: CamInt_resetCam
Function Description: This function is responsible
for resetting the camera. This is accomplished by
toggling the reset line on the OV6620 for ~100 mS.
Inputs: none
Outputs: none
IMPORTANT NOTE: This function has effectively been removed
since resetting the camera now causes the camera to not
AVRcam.elf: file format elf32-avr
Sections:
Idx Name Size VMA LMA File off Algn
0 .noinit 00000030 00800300 00800300 00001182 2**0
ALLOC
1 .bss 00000274 00800070 00800070 00001182 2**0
ALLOC
2 .data 00000010 00800060 000010be 00001172 2**0
CONTENTS, ALLOC, LOAD, DATA
3 .text 000010be 00000000 00000000 000000b4 2**1
CONTENTS, ALLOC, LOAD, READONLY, CODE
4 .eeprom 00000000 00810000 00810000 00001182 2**0
CONTENTS
5 .stab 00003ed0 00000000 00000000 00001184 2**2
CONTENTS, READONLY, DEBUGGING
6 .stabstr 000017c9 00000000 00000000 00005054 2**0
CONTENTS, READONLY, DEBUGGING
Disassembly of section .text:
00000000 <__vectors>:
0: 63 c0 rjmp .+198 ; 0xc8 <__init>
2: 05 c8 rjmp .-4086 ; 0xfffff00e <__eeprom_end+0xff7ef00e>
4: 05 c8 rjmp .-4086 ; 0xfffff010 <__eeprom_end+0xff7ef010>
6: 7a c0 rjmp .+244 ; 0xfc <__bad_interrupt>
8: 79 c0 rjmp .+242 ; 0xfc <__bad_interrupt>
a: 78 c0 rjmp .+240 ; 0xfc <__bad_interrupt>
c: 77 c0 rjmp .+238 ; 0xfc <__bad_interrupt>
e: 76 c0 rjmp .+236 ; 0xfc <__bad_interrupt>
10: 00 c8 rjmp .-4096 ; 0xfffff012 <__eeprom_end+0xff7ef012>
12: 74 c0 rjmp .+232 ; 0xfc <__bad_interrupt>
14: 73 c0 rjmp .+230 ; 0xfc <__bad_interrupt>
16: aa c5 rjmp .+2900 ; 0xb6c <__vector_11>
18: 71 c0 rjmp .+226 ; 0xfc <__bad_interrupt>
1a: 70 c0 rjmp .+224 ; 0xfc <__bad_interrupt>
1c: 6f c0 rjmp .+222 ; 0xfc <__bad_interrupt>
1e: 6e c0 rjmp .+220 ; 0xfc <__bad_interrupt>
20: 6d c0 rjmp .+218 ; 0xfc <__bad_interrupt>
22: 0f c6 rjmp .+3102 ; 0xc42 <__vector_17>
24: 6b c0 rjmp .+214 ; 0xfc <__bad_interrupt>
00000026 <__ctors_end>:
26: 29 c6 rjmp .+3154 ; 0xc7a <__vector_17+0x38>
28: bf c6 rjmp .+3454 ; 0xda8 <__vector_17+0x166>
2a: be c6 rjmp .+3452 ; 0xda8 <__vector_17+0x166>
2c: bd c6 rjmp .+3450 ; 0xda8 <__vector_17+0x166>
2e: bc c6 rjmp .+3448 ; 0xda8 <__vector_17+0x166>
30: bb c6 rjmp .+3446 ; 0xda8 <__vector_17+0x166>
32: ba c6 rjmp .+3444 ; 0xda8 <__vector_17+0x166>
34: b9 c6 rjmp .+3442 ; 0xda8 <__vector_17+0x166>
36: 21 c6 rjmp .+3138 ; 0xc7a <__vector_17+0x38>
38: b7 c6 rjmp .+3438 ; 0xda8 <__vector_17+0x166>
3a: b6 c6 rjmp .+3436 ; 0xda8 <__vector_17+0x166>
3c: b5 c6 rjmp .+3434 ; 0xda8 <__vector_17+0x166>
3e: b4 c6 rjmp .+3432 ; 0xda8 <__vector_17+0x166>
40: b3 c6 rjmp .+3430 ; 0xda8 <__vector_17+0x166>
42: b2 c6 rjmp .+3428 ; 0xda8 <__vector_17+0x166>
44: b1 c6 rjmp .+3426 ; 0xda8 <__vector_17+0x166>
46: 31 c6 rjmp .+3170 ; 0xcaa <__vector_17+0x68>
48: af c6 rjmp .+3422 ; 0xda8 <__vector_17+0x166>
4a: ae c6 rjmp .+3420 ; 0xda8 <__vector_17+0x166>
4c: ad c6 rjmp .+3418 ; 0xda8 <__vector_17+0x166>
4e: ac c6 rjmp .+3416 ; 0xda8 <__vector_17+0x166>
50: ab c6 rjmp .+3414 ; 0xda8 <__vector_17+0x166>
52: aa c6 rjmp .+3412 ; 0xda8 <__vector_17+0x166>
54: a9 c6 rjmp .+3410 ; 0xda8 <__vector_17+0x166>
56: 3a c6 rjmp .+3188 ; 0xccc <__vector_17+0x8a>
58: a7 c6 rjmp .+3406 ; 0xda8 <__vector_17+0x166>
5a: a6 c6 rjmp .+3404 ; 0xda8 <__vector_17+0x166>
5c: a5 c6 rjmp .+3402 ; 0xda8 <__vector_17+0x166>
5e: a4 c6 rjmp .+3400 ; 0xda8 <__vector_17+0x166>
60: a3 c6 rjmp .+3398 ; 0xda8 <__vector_17+0x166>
62: a2 c6 rjmp .+3396 ; 0xda8 <__vector_17+0x166>
64: a1 c6 rjmp .+3394 ; 0xda8 <__vector_17+0x166>
66: 3b c6 rjmp .+3190 ; 0xcde <__vector_17+0x9c>
68: 9f c6 rjmp .+3390 ; 0xda8 <__vector_17+0x166>
6a: 9e c6 rjmp .+3388 ; 0xda8 <__vector_17+0x166>
6c: 9d c6 rjmp .+3386 ; 0xda8 <__vector_17+0x166>
6e: 9c c6 rjmp .+3384 ; 0xda8 <__vector_17+0x166>
70: 9b c6 rjmp .+3382 ; 0xda8 <__vector_17+0x166>
72: 9a c6 rjmp .+3380 ; 0xda8 <__vector_17+0x166>
74: 99 c6 rjmp .+3378 ; 0xda8 <__vector_17+0x166>
76: 54 c6 rjmp .+3240 ; 0xd20 <__vector_17+0xde>
78: 97 c6 rjmp .+3374 ; 0xda8 <__vector_17+0x166>
7a: 96 c6 rjmp .+3372 ; 0xda8 <__vector_17+0x166>
7c: 95 c6 rjmp .+3370 ; 0xda8 <__vector_17+0x166>
7e: 94 c6 rjmp .+3368 ; 0xda8 <__vector_17+0x166>
80: 93 c6 rjmp .+3366 ; 0xda8 <__vector_17+0x166>
82: 92 c6 rjmp .+3364 ; 0xda8 <__vector_17+0x166>
84: 91 c6 rjmp .+3362 ; 0xda8 <__vector_17+0x166>
86: 90 c6 rjmp .+3360 ; 0xda8 <__vector_17+0x166>
88: 8f c6 rjmp .+3358 ; 0xda8 <__vector_17+0x166>
8a: 8e c6 rjmp .+3356 ; 0xda8 <__vector_17+0x166>
8c: 8d c6 rjmp .+3354 ; 0xda8 <__vector_17+0x166>
8e: 8c c6 rjmp .+3352 ; 0xda8 <__vector_17+0x166>
90: 8b c6 rjmp .+3350 ; 0xda8 <__vector_17+0x166>
92: 8a c6 rjmp .+3348 ; 0xda8 <__vector_17+0x166>
94: 89 c6 rjmp .+3346 ; 0xda8 <__vector_17+0x166>
96: 4d c6 rjmp .+3226 ; 0xd32 <__vector_17+0xf0>
98: 87 c6 rjmp .+3342 ; 0xda8 <__vector_17+0x166>
9a: 86 c6 rjmp .+3340 ; 0xda8 <__vector_17+0x166>
9c: 85 c6 rjmp .+3338 ; 0xda8 <__vector_17+0x166>
9e: 84 c6 rjmp .+3336 ; 0xda8 <__vector_17+0x166>
a0: 83 c6 rjmp .+3334 ; 0xda8 <__vector_17+0x166>
a2: 82 c6 rjmp .+3332 ; 0xda8 <__vector_17+0x166>
a4: 81 c6 rjmp .+3330 ; 0xda8 <__vector_17+0x166>
a6: 12 c6 rjmp .+3108 ; 0xccc <__vector_17+0x8a>
a8: 7f c6 rjmp .+3326 ; 0xda8 <__vector_17+0x166>
aa: 7e c6 rjmp .+3324 ; 0xda8 <__vector_17+0x166>
ac: 7d c6 rjmp .+3322 ; 0xda8 <__vector_17+0x166>
ae: 7c c6 rjmp .+3320 ; 0xda8 <__vector_17+0x166>
b0: 7b c6 rjmp .+3318 ; 0xda8 <__vector_17+0x166>
b2: 7a c6 rjmp .+3316 ; 0xda8 <__vector_17+0x166>
b4: 79 c6 rjmp .+3314 ; 0xda8 <__vector_17+0x166>
b6: 4e c6 rjmp .+3228 ; 0xd54 <__vector_17+0x112>
b8: 77 c6 rjmp .+3310 ; 0xda8 <__vector_17+0x166>
ba: 76 c6 rjmp .+3308 ; 0xda8 <__vector_17+0x166>
bc: 75 c6 rjmp .+3306 ; 0xda8 <__vector_17+0x166>
be: 74 c6 rjmp .+3304 ; 0xda8 <__vector_17+0x166>
c0: 73 c6 rjmp .+3302 ; 0xda8 <__vector_17+0x166>
c2: 72 c6 rjmp .+3300 ; 0xda8 <__vector_17+0x166>
c4: 71 c6 rjmp .+3298 ; 0xda8 <__vector_17+0x166>
c6: 62 c6 rjmp .+3268 ; 0xd8c <__vector_17+0x14a>
000000c8 <__init>:
c8: 11 24 eor r1, r1
ca: 1f be out 0x3f, r1 ; 63
cc: cf e5 ldi r28, 0x5F ; 95
ce: d4 e0 ldi r29, 0x04 ; 4
d0: de bf out 0x3e, r29 ; 62
d2: cd bf out 0x3d, r28 ; 61
000000d4 <__do_copy_data>:
d4: 10 e0 ldi r17, 0x00 ; 0
d6: a0 e6 ldi r26, 0x60 ; 96
d8: b0 e0 ldi r27, 0x00 ; 0
da: ee eb ldi r30, 0xBE ; 190
dc: f0 e1 ldi r31, 0x10 ; 16
de: 02 c0 rjmp .+4 ; 0xe4 <.do_copy_data_start>
000000e0 <.do_copy_data_loop>:
e0: 05 90 lpm r0, Z+
e2: 0d 92 st X+, r0
000000e4 <.do_copy_data_start>:
e4: a0 37 cpi r26, 0x70 ; 112
e6: b1 07 cpc r27, r17
e8: d9 f7 brne .-10 ; 0xe0 <.do_copy_data_loop>
000000ea <__do_clear_bss>:
ea: 12 e0 ldi r17, 0x02 ; 2
ec: a0 e7 ldi r26, 0x70 ; 112
ee: b0 e0 ldi r27, 0x00 ; 0
f0: 01 c0 rjmp .+2 ; 0xf4 <.do_clear_bss_start>
000000f2 <.do_clear_bss_loop>:
f2: 1d 92 st X+, r1
000000f4 <.do_clear_bss_start>:
f4: a4 3e cpi r26, 0xE4 ; 228
f6: b1 07 cpc r27, r17
f8: e1 f7 brne .-8 ; 0xf2 <.do_clear_bss_loop>
fa: 30 c0 rjmp .+96 ; 0x15c <main>
000000fc <__bad_interrupt>:
fc: 91 c7 rjmp .+3874 ; 0x1020 <__vector_default>
000000fe <CamInt_resetCam>:
output the clock signal. Thus, if we reset the cam, the
AVR has no clock, and thus doesn't run...
***********************************************************/
void CamInt_resetCam(void)
{
15c: 08 95 ret
0000015e <main>:
fe: 08 95 ret
00000100 <CamInt_init>:
100: 8f 9a sbi 0x11, 7 ; 17
102: 8f 9a sbi 0x11, 7 ; 17
104: 8a 98 cbi 0x11, 2 ; 17
106: 97 98 cbi 0x12, 7 ; 18
108: 87 b3 in r24, 0x17 ; 23
10a: 80 7f andi r24, 0xF0 ; 240
10c: 87 bb out 0x17, r24 ; 23
10e: 87 b3 in r24, 0x17 ; 23
110: 80 6f ori r24, 0xF0 ; 240
112: 87 bb out 0x17, r24 ; 23
114: 84 b3 in r24, 0x14 ; 20
116: 80 7f andi r24, 0xF0 ; 240
118: 84 bb out 0x14, r24 ; 20
11a: 8e b5 in r24, 0x2e ; 46
11c: 88 7f andi r24, 0xF8 ; 248
11e: 8e bd out 0x2e, r24 ; 46
120: 85 b7 in r24, 0x35 ; 53
122: 8c 60 ori r24, 0x0C ; 12
124: 85 bf out 0x35, r24 ; 53
126: 85 b7 in r24, 0x35 ; 53
128: 83 60 ori r24, 0x03 ; 3
12a: 85 bf out 0x35, r24 ; 53
12c: 8b b7 in r24, 0x3b ; 59
12e: 80 64 ori r24, 0x40 ; 64
130: 8b bf out 0x3b, r24 ; 59
132: 86 e0 ldi r24, 0x06 ; 6
134: 83 bf out 0x33, r24 ; 51
136: 85 b7 in r24, 0x35 ; 53
138: 8f 78 andi r24, 0x8F ; 143
13a: 85 bf out 0x35, r24 ; 53
13c: 85 b7 in r24, 0x35 ; 53
13e: 80 68 ori r24, 0x80 ; 128
140: 85 bf out 0x35, r24 ; 53
142: e0 e0 ldi r30, 0x00 ; 0
144: f3 e0 ldi r31, 0x03 ; 3
146: 80 e3 ldi r24, 0x30 ; 48
148: df 01 movw r26, r30
14a: 98 2f mov r25, r24
14c: 1d 92 st X+, r1
14e: 9a 95 dec r25
150: e9 f7 brne .-6 ; 0x14c <CamInt_init+0x4c>
/* Needed in order to truncate to 8 bit. */
uint8_t len;
len = (uint8_t) n;
asm volatile (
152: a1 e0 ldi r26, 0x01 ; 1
154: b0 e0 ldi r27, 0x00 ; 0
156: 18 2e mov r1, r24
158: a0 d7 rcall .+3904 ; 0x109a <__eeprom_read_block_1C1D1E>
15a: 08 95 ret
0000015c <main>:
Inputs: none
Outputs: int
***********************************************************/
int main(void)
{
15e: cf e5 ldi r28, 0x5F ; 95
160: d4 e0 ldi r29, 0x04 ; 4
162: de bf out 0x3e, r29 ; 62
164: cd bf out 0x3d, r28 ; 61
15c: cf e5 ldi r28, 0x5F ; 95
15e: d4 e0 ldi r29, 0x04 ; 4
160: de bf out 0x3e, r29 ; 62
162: cd bf out 0x3d, r28 ; 61
/* initialize all of the interface modules */
DebugInt_init();
166: aa d6 rcall .+3412 ; 0xebc
164: cf d6 rcall .+3486 ; 0xf04 <DebugInt_init>
UartInt_init();
168: f1 d4 rcall .+2530 ; 0xb4c
166: f4 d4 rcall .+2536 ; 0xb50 <UartInt_init>
I2CInt_init();
16a: 2c d5 rcall .+2648 ; 0xbc4
168: 2b d5 rcall .+2646 ; 0xbc0 <I2CInt_init>
CamInt_init();
16c: c8 df rcall .-112 ; 0xfe
16a: ca df rcall .-108 ; 0x100 <CamInt_init>
/* initialize the remaining modules that will process
data...interrupts need to be on for these */
ENABLE_INTS();
16e: 78 94 sei
16c: 78 94 sei
CamConfig_init();
170: fa d5 rcall .+3060 ; 0xd66
16e: 7e d6 rcall .+3324 ; 0xe6c <CamConfig_init>
UIMgr_init();
172: 94 d2 rcall .+1320 ; 0x69c
170: 8a d3 rcall .+1812 ; 0x886 <UIMgr_init>
FrameMgr_init();
174: 7f d0 rcall .+254 ; 0x274
172: 37 d2 rcall .+1134 ; 0x5e2 <FrameMgr_init>
/* provide a short delay for the camera to stabilize before
we let the executive start up */
Utility_delay(1000);
176: 88 ee ldi r24, 0xE8 ; 232
178: 93 e0 ldi r25, 0x03 ; 3
17a: 65 d6 rcall .+3274 ; 0xe46
174: 88 ee ldi r24, 0xE8 ; 232
176: 93 e0 ldi r25, 0x03 ; 3
178: 8a d6 rcall .+3348 ; 0xe8e <Utility_delay>
/* the rest of the application will be under the
control of the Executive. */
Exec_run();
17c: 03 d0 rcall .+6 ; 0x184
17a: 11 d0 rcall .+34 ; 0x19e <Exec_run>
/* this should never be reached */
return(0);
}
17e: 80 e0 ldi r24, 0x00 ; 0
180: 90 e0 ldi r25, 0x00 ; 0
182: 8c c7 rjmp .+3864 ; 0x109c
17c: 80 e0 ldi r24, 0x00 ; 0
17e: 90 e0 ldi r25, 0x00 ; 0
180: 9d c7 rjmp .+3898 ; 0x10bc <_exit>
00000182 <Exec_writeEventFifo>:
00000184 <Exec_run>:
Inputs: none
Outputs: none
***********************************************************/
void Exec_run(void)
{
184: cf 93 push r28
unsigned char eventGenerated;
while(1)
{
if (fastEventBitmask)
186: 80 91 72 00 lds r24, 0x0072
18a: 88 23 and r24, r24
18c: b9 f0 breq .+46 ; 0x1bc
{
/* an event needing fast processing has been received */
/* a received line needs to be processed...this
needs to be processed as quickly as possible */
if (fastEventBitmask & FEV_ACQUIRE_LINE_COMPLETE)
18e: 80 ff sbrs r24, 0
190: 09 c0 rjmp .+18 ; 0x1a4
{
DISABLE_INTS();
192: f8 94 cli
fastEventBitmask &= ~FEV_ACQUIRE_LINE_COMPLETE;
194: 80 91 72 00 lds r24, 0x0072
198: 8e 7f andi r24, 0xFE ; 254
19a: 80 93 72 00 sts 0x0072, r24
ENABLE_INTS();
19e: 78 94 sei
FrameMgr_processLine();
1a0: f8 d0 rcall .+496 ; 0x392
/* also check if serial data needs to be sent
out through UIMgr */
UIMgr_transmitPendingData();
1a2: ac d2 rcall .+1368 ; 0x6fc
182: f8 94 cli
184: 90 91 70 00 lds r25, 0x0070
188: ec e6 ldi r30, 0x6C ; 108
18a: f2 e0 ldi r31, 0x02 ; 2
18c: e9 0f add r30, r25
18e: f1 1d adc r31, r1
190: 80 83 st Z, r24
192: 9f 5f subi r25, 0xFF ; 255
194: 97 70 andi r25, 0x07 ; 7
196: 90 93 70 00 sts 0x0070, r25
19a: 78 94 sei
19c: 08 95 ret
0000019e <Exec_run>:
19e: 80 91 72 00 lds r24, 0x0072
1a2: 88 23 and r24, r24
1a4: 99 f0 breq .+38 ; 0x1cc <Exec_run+0x2e>
1a6: 80 ff sbrs r24, 0
1a8: 07 c0 rjmp .+14 ; 0x1b8 <Exec_run+0x1a>
1aa: f8 94 cli
1ac: 8e 7f andi r24, 0xFE ; 254
1ae: 80 93 72 00 sts 0x0072, r24
1b2: 78 94 sei
1b4: b6 d0 rcall .+364 ; 0x322 <FrameMgr_processLine>
1b6: ff d2 rcall .+1534 ; 0x7b6 <UIMgr_transmitPendingData>
1b8: 80 91 72 00 lds r24, 0x0072
1bc: 81 ff sbrs r24, 1
1be: 06 c0 rjmp .+12 ; 0x1cc <Exec_run+0x2e>
1c0: f8 94 cli
1c2: 8d 7f andi r24, 0xFD ; 253
1c4: 80 93 72 00 sts 0x0072, r24
1c8: 78 94 sei
1ca: 12 d2 rcall .+1060 ; 0x5f0 <FrameMgr_acquireLine>
1cc: 20 91 71 00 lds r18, 0x0071
1d0: 80 91 70 00 lds r24, 0x0070
1d4: 82 17 cp r24, r18
1d6: 19 f3 breq .-58 ; 0x19e <Exec_run>
1d8: f8 94 cli
1da: e2 2f mov r30, r18
1dc: ff 27 eor r31, r31
1de: e4 59 subi r30, 0x94 ; 148
1e0: fd 4f sbci r31, 0xFD ; 253
1e2: 90 81 ld r25, Z
1e4: 82 2f mov r24, r18
1e6: 8f 5f subi r24, 0xFF ; 255
1e8: 87 70 andi r24, 0x07 ; 7
1ea: 80 93 71 00 sts 0x0071, r24
1ee: 78 94 sei
1f0: 89 2f mov r24, r25
1f2: 99 27 eor r25, r25
1f4: 80 31 cpi r24, 0x10 ; 16
1f6: 31 f1 breq .+76 ; 0x244 <Exec_run+0xa6>
1f8: 81 31 cpi r24, 0x11 ; 17
1fa: 68 f4 brcc .+26 ; 0x216 <Exec_run+0x78>
1fc: 82 30 cpi r24, 0x02 ; 2
1fe: c9 f0 breq .+50 ; 0x232 <Exec_run+0x94>
200: 83 30 cpi r24, 0x03 ; 3
202: 18 f4 brcc .+6 ; 0x20a <Exec_run+0x6c>
204: 81 30 cpi r24, 0x01 ; 1
206: 59 f6 brne .-106 ; 0x19e <Exec_run>
208: 2b c0 rjmp .+86 ; 0x260 <Exec_run+0xc2>
20a: 84 30 cpi r24, 0x04 ; 4
20c: 31 f1 breq .+76 ; 0x25a <Exec_run+0xbc>
20e: 88 30 cpi r24, 0x08 ; 8
210: 09 f0 breq .+2 ; 0x214 <Exec_run+0x76>
212: c5 cf rjmp .-118 ; 0x19e <Exec_run>
214: 1f c0 rjmp .+62 ; 0x254 <Exec_run+0xb6>
216: 80 38 cpi r24, 0x80 ; 128
218: 79 f0 breq .+30 ; 0x238 <Exec_run+0x9a>
21a: 81 38 cpi r24, 0x81 ; 129
21c: 20 f4 brcc .+8 ; 0x226 <Exec_run+0x88>
21e: 80 32 cpi r24, 0x20 ; 32
220: 09 f0 breq .+2 ; 0x224 <Exec_run+0x86>
222: bd cf rjmp .-134 ; 0x19e <Exec_run>
224: 14 c0 rjmp .+40 ; 0x24e <Exec_run+0xb0>
226: 81 38 cpi r24, 0x81 ; 129
228: 51 f0 breq .+20 ; 0x23e <Exec_run+0xa0>
22a: 80 39 cpi r24, 0x90 ; 144
22c: 09 f0 breq .+2 ; 0x230 <Exec_run+0x92>
22e: b7 cf rjmp .-146 ; 0x19e <Exec_run>
230: 1c c0 rjmp .+56 ; 0x26a <Exec_run+0xcc>
232: 82 e0 ldi r24, 0x02 ; 2
234: 2e d2 rcall .+1116 ; 0x692 <FrameMgr_dispatchEvent>
236: b3 cf rjmp .-154 ; 0x19e <Exec_run>
238: 80 e8 ldi r24, 0x80 ; 128
23a: 2b d2 rcall .+1110 ; 0x692 <FrameMgr_dispatchEvent>
23c: b0 cf rjmp .-160 ; 0x19e <Exec_run>
23e: 81 e8 ldi r24, 0x81 ; 129
240: 28 d2 rcall .+1104 ; 0x692 <FrameMgr_dispatchEvent>
242: ad cf rjmp .-166 ; 0x19e <Exec_run>
244: 80 e1 ldi r24, 0x10 ; 16
246: 25 d2 rcall .+1098 ; 0x692 <FrameMgr_dispatchEvent>
248: 80 e1 ldi r24, 0x10 ; 16
24a: 75 d4 rcall .+2282 ; 0xb36 <UIMgr_dispatchEvent>
24c: a8 cf rjmp .-176 ; 0x19e <Exec_run>
24e: 80 e2 ldi r24, 0x20 ; 32
250: 20 d2 rcall .+1088 ; 0x692 <FrameMgr_dispatchEvent>
252: a5 cf rjmp .-182 ; 0x19e <Exec_run>
254: 88 e0 ldi r24, 0x08 ; 8
256: 1d d2 rcall .+1082 ; 0x692 <FrameMgr_dispatchEvent>
258: a2 cf rjmp .-188 ; 0x19e <Exec_run>
25a: 84 e0 ldi r24, 0x04 ; 4
25c: 1a d2 rcall .+1076 ; 0x692 <FrameMgr_dispatchEvent>
25e: 9f cf rjmp .-194 ; 0x19e <Exec_run>
260: 81 e0 ldi r24, 0x01 ; 1
262: 69 d4 rcall .+2258 ; 0xb36 <UIMgr_dispatchEvent>
264: 81 e0 ldi r24, 0x01 ; 1
266: 15 d2 rcall .+1066 ; 0x692 <FrameMgr_dispatchEvent>
268: 9a cf rjmp .-204 ; 0x19e <Exec_run>
26a: 80 e9 ldi r24, 0x90 ; 144
26c: 64 d4 rcall .+2248 ; 0xb36 <UIMgr_dispatchEvent>
26e: 97 cf rjmp .-210 ; 0x19e <Exec_run>
00000270 <FrameMgr_processFrame>:
270: df 92 push r13
272: ef 92 push r14
274: ff 92 push r15
276: 0f 93 push r16
278: 1f 93 push r17
27a: cf 93 push r28
27c: df 93 push r29
27e: 20 91 60 00 lds r18, 0x0060
282: 30 91 61 00 lds r19, 0x0061
286: 80 91 73 00 lds r24, 0x0073
28a: 88 23 and r24, r24
28c: 09 f4 brne .+2 ; 0x290 <FrameMgr_processFrame+0x20>
28e: 3f c0 rjmp .+126 ; 0x30e <FrameMgr_processFrame+0x9e>
290: e9 01 movw r28, r18
292: 8a e0 ldi r24, 0x0A ; 10
294: 5c d2 rcall .+1208 ; 0x74e <UIMgr_writeTxFifo>
296: 80 91 73 00 lds r24, 0x0073
29a: 59 d2 rcall .+1202 ; 0x74e <UIMgr_writeTxFifo>
29c: dd 24 eor r13, r13
29e: 8f 81 ldd r24, Y+7 ; 0x07
2a0: 81 30 cpi r24, 0x01 ; 1
2a2: 69 f5 brne .+90 ; 0x2fe <FrameMgr_processFrame+0x8e>
2a4: 88 81 ld r24, Y
2a6: 80 38 cpi r24, 0x80 ; 128
2a8: e1 f0 breq .+56 ; 0x2e2 <FrameMgr_processFrame+0x72>
2aa: 80 34 cpi r24, 0x40 ; 64
2ac: 11 f4 brne .+4 ; 0x2b2 <FrameMgr_processFrame+0x42>
2ae: 81 e0 ldi r24, 0x01 ; 1
2b0: 19 c0 rjmp .+50 ; 0x2e4 <FrameMgr_processFrame+0x74>
2b2: 80 32 cpi r24, 0x20 ; 32
2b4: 11 f4 brne .+4 ; 0x2ba <FrameMgr_processFrame+0x4a>
2b6: 82 e0 ldi r24, 0x02 ; 2
2b8: 15 c0 rjmp .+42 ; 0x2e4 <FrameMgr_processFrame+0x74>
2ba: 80 31 cpi r24, 0x10 ; 16
2bc: 11 f4 brne .+4 ; 0x2c2 <FrameMgr_processFrame+0x52>
2be: 83 e0 ldi r24, 0x03 ; 3
2c0: 11 c0 rjmp .+34 ; 0x2e4 <FrameMgr_processFrame+0x74>
2c2: 88 30 cpi r24, 0x08 ; 8
2c4: 11 f4 brne .+4 ; 0x2ca <FrameMgr_processFrame+0x5a>
2c6: 84 e0 ldi r24, 0x04 ; 4
2c8: 0d c0 rjmp .+26 ; 0x2e4 <FrameMgr_processFrame+0x74>
2ca: 84 30 cpi r24, 0x04 ; 4
2cc: 11 f4 brne .+4 ; 0x2d2 <FrameMgr_processFrame+0x62>
2ce: 85 e0 ldi r24, 0x05 ; 5
2d0: 09 c0 rjmp .+18 ; 0x2e4 <FrameMgr_processFrame+0x74>
2d2: 82 30 cpi r24, 0x02 ; 2
2d4: 11 f4 brne .+4 ; 0x2da <FrameMgr_processFrame+0x6a>
2d6: 86 e0 ldi r24, 0x06 ; 6
2d8: 05 c0 rjmp .+10 ; 0x2e4 <FrameMgr_processFrame+0x74>
2da: 81 30 cpi r24, 0x01 ; 1
2dc: 11 f4 brne .+4 ; 0x2e2 <FrameMgr_processFrame+0x72>
2de: 87 e0 ldi r24, 0x07 ; 7
2e0: 01 c0 rjmp .+2 ; 0x2e4 <FrameMgr_processFrame+0x74>
2e2: 80 e0 ldi r24, 0x00 ; 0
2e4: 1b 81 ldd r17, Y+3 ; 0x03
2e6: 0c 81 ldd r16, Y+4 ; 0x04
2e8: fd 80 ldd r15, Y+5 ; 0x05
2ea: ee 80 ldd r14, Y+6 ; 0x06
2ec: 30 d2 rcall .+1120 ; 0x74e <UIMgr_writeTxFifo>
2ee: 81 2f mov r24, r17
2f0: 2e d2 rcall .+1116 ; 0x74e <UIMgr_writeTxFifo>
2f2: 80 2f mov r24, r16
2f4: 2c d2 rcall .+1112 ; 0x74e <UIMgr_writeTxFifo>
2f6: 8f 2d mov r24, r15
2f8: 2a d2 rcall .+1108 ; 0x74e <UIMgr_writeTxFifo>
2fa: 8e 2d mov r24, r14
2fc: 28 d2 rcall .+1104 ; 0x74e <UIMgr_writeTxFifo>
2fe: d3 94 inc r13
300: 88 e0 ldi r24, 0x08 ; 8
302: d8 16 cp r13, r24
304: 11 f0 breq .+4 ; 0x30a <FrameMgr_processFrame+0x9a>
306: 28 96 adiw r28, 0x08 ; 8
308: ca cf rjmp .-108 ; 0x29e <FrameMgr_processFrame+0x2e>
30a: 8f ef ldi r24, 0xFF ; 255
30c: 20 d2 rcall .+1088 ; 0x74e <UIMgr_writeTxFifo>
30e: 84 e0 ldi r24, 0x04 ; 4
310: 38 df rcall .-400 ; 0x182 <Exec_writeEventFifo>
312: df 91 pop r29
314: cf 91 pop r28
316: 1f 91 pop r17
318: 0f 91 pop r16
31a: ff 90 pop r15
31c: ef 90 pop r14
31e: df 90 pop r13
320: 08 95 ret
00000322 <FrameMgr_processLine>:
322: 2f 92 push r2
324: 3f 92 push r3
326: 4f 92 push r4
328: 5f 92 push r5
32a: 6f 92 push r6
32c: 7f 92 push r7
32e: 8f 92 push r8
330: 9f 92 push r9
332: af 92 push r10
334: bf 92 push r11
336: cf 92 push r12
338: df 92 push r13
33a: ef 92 push r14
33c: ff 92 push r15
33e: 0f 93 push r16
340: 1f 93 push r17
342: cf 93 push r28
344: df 93 push r29
346: cd b7 in r28, 0x3d ; 61
348: de b7 in r29, 0x3e ; 62
34a: 21 97 sbiw r28, 0x01 ; 1
34c: 0f b6 in r0, 0x3f ; 63
34e: f8 94 cli
350: de bf out 0x3e, r29 ; 62
352: 0f be out 0x3f, r0 ; 63
354: cd bf out 0x3d, r28 ; 61
356: 00 91 60 00 lds r16, 0x0060
35a: 10 91 61 00 lds r17, 0x0061
35e: 80 91 74 00 lds r24, 0x0074
362: 82 30 cpi r24, 0x02 ; 2
364: 09 f0 breq .+2 ; 0x368 <FrameMgr_processLine+0x46>
366: 6a c0 rjmp .+212 ; 0x43c <FrameMgr_processLine+0x11a>
368: 8b e0 ldi r24, 0x0B ; 11
36a: fc d3 rcall .+2040 ; 0xb64 <UartInt_txByte>
36c: 80 91 75 00 lds r24, 0x0075
370: f9 d3 rcall .+2034 ; 0xb64 <UartInt_txByte>
372: 0f 2e mov r0, r31
374: fc eb ldi r31, 0xBC ; 188
376: cf 2e mov r12, r31
378: f1 e0 ldi r31, 0x01 ; 1
37a: df 2e mov r13, r31
37c: f0 2d mov r31, r0
37e: 00 e0 ldi r16, 0x00 ; 0
380: 10 e0 ldi r17, 0x00 ; 0
382: 0f 2e mov r0, r31
384: fc e0 ldi r31, 0x0C ; 12
386: ef 2e mov r14, r31
388: f1 e0 ldi r31, 0x01 ; 1
38a: ff 2e mov r15, r31
38c: f0 2d mov r31, r0
38e: f6 01 movw r30, r12
390: 80 81 ld r24, Z
392: 89 83 std Y+1, r24 ; 0x01
394: 89 81 ldd r24, Y+1 ; 0x01
396: 8f 70 andi r24, 0x0F ; 15
398: 89 83 std Y+1, r24 ; 0x01
39a: 89 81 ldd r24, Y+1 ; 0x01
39c: 82 95 swap r24
39e: 80 7f andi r24, 0xF0 ; 240
3a0: 89 83 std Y+1, r24 ; 0x01
3a2: 99 81 ldd r25, Y+1 ; 0x01
3a4: f7 01 movw r30, r14
3a6: 80 81 ld r24, Z
3a8: 8f 70 andi r24, 0x0F ; 15
3aa: 89 2b or r24, r25
3ac: 89 83 std Y+1, r24 ; 0x01
3ae: 89 81 ldd r24, Y+1 ; 0x01
3b0: d9 d3 rcall .+1970 ; 0xb64 <UartInt_txByte>
3b2: d8 01 movw r26, r16
3b4: 11 96 adiw r26, 0x01 ; 1
3b6: fd 01 movw r30, r26
3b8: e4 5f subi r30, 0xF4 ; 244
3ba: fe 4f sbci r31, 0xFE ; 254
3bc: 80 81 ld r24, Z
3be: 89 83 std Y+1, r24 ; 0x01
3c0: 89 81 ldd r24, Y+1 ; 0x01
3c2: 8f 70 andi r24, 0x0F ; 15
3c4: 89 83 std Y+1, r24 ; 0x01
3c6: 89 81 ldd r24, Y+1 ; 0x01
3c8: 82 95 swap r24
3ca: 80 7f andi r24, 0xF0 ; 240
3cc: 89 83 std Y+1, r24 ; 0x01
3ce: 99 81 ldd r25, Y+1 ; 0x01
3d0: a4 54 subi r26, 0x44 ; 68
3d2: be 4f sbci r27, 0xFE ; 254
3d4: 8c 91 ld r24, X
3d6: 8f 70 andi r24, 0x0F ; 15
3d8: 89 2b or r24, r25
3da: 89 83 std Y+1, r24 ; 0x01
3dc: 89 81 ldd r24, Y+1 ; 0x01
3de: c2 d3 rcall .+1924 ; 0xb64 <UartInt_txByte>
3e0: 82 e0 ldi r24, 0x02 ; 2
3e2: 90 e0 ldi r25, 0x00 ; 0
3e4: c8 0e add r12, r24
3e6: d9 1e adc r13, r25
3e8: 0e 5f subi r16, 0xFE ; 254
3ea: 1f 4f sbci r17, 0xFF ; 255
3ec: e8 0e add r14, r24
3ee: f9 1e adc r15, r25
3f0: 00 3b cpi r16, 0xB0 ; 176
3f2: 11 05 cpc r17, r1
3f4: 61 f6 brne .-104 ; 0x38e <FrameMgr_processLine+0x6c>
3f6: 8f e0 ldi r24, 0x0F ; 15
3f8: b5 d3 rcall .+1898 ; 0xb64 <UartInt_txByte>
3fa: 80 91 75 00 lds r24, 0x0075
3fe: 8f 5f subi r24, 0xFF ; 255
400: 80 93 75 00 sts 0x0075, r24
404: 88 34 cpi r24, 0x48 ; 72
406: 60 f0 brcs .+24 ; 0x420 <FrameMgr_processLine+0xfe>
408: 10 92 75 00 sts 0x0075, r1
40c: 10 92 74 00 sts 0x0074, r1
410: 89 b7 in r24, 0x39 ; 57
412: 8b 7f andi r24, 0xFB ; 251
414: 89 bf out 0x39, r24 ; 57
416: 60 e0 ldi r22, 0x00 ; 0
418: 81 e1 ldi r24, 0x11 ; 17
41a: e9 d4 rcall .+2514 ; 0xdee <CamConfig_setCamReg>
41c: ed d4 rcall .+2522 ; 0xdf8 <CamConfig_sendFifoCmds>
41e: c8 c0 rjmp .+400 ; 0x5b0 <__stack+0x151>
420: 80 91 72 00 lds r24, 0x0072
424: 82 60 ori r24, 0x02 ; 2
426: 80 93 72 00 sts 0x0072, r24
42a: c2 c0 rjmp .+388 ; 0x5b0 <__stack+0x151>
42c: 80 e2 ldi r24, 0x20 ; 32
42e: a9 de rcall .-686 ; 0x182 <Exec_writeEventFifo>
430: 89 b7 in r24, 0x39 ; 57
432: 8b 7f andi r24, 0xFB ; 251
434: 89 bf out 0x39, r24 ; 57
436: 10 92 76 00 sts 0x0076, r1
43a: ba c0 rjmp .+372 ; 0x5b0 <__stack+0x151>
43c: 81 30 cpi r24, 0x01 ; 1
43e: 09 f0 breq .+2 ; 0x442 <FrameMgr_processLine+0x120>
440: b7 c0 rjmp .+366 ; 0x5b0 <__stack+0x151>
442: f0 90 76 00 lds r15, 0x0076
446: cf 2c mov r12, r15
448: dd 24 eor r13, r13
44a: 36 01 movw r6, r12
44c: 08 94 sec
44e: 61 08 sbc r6, r1
450: 71 08 sbc r7, r1
452: 70 91 73 00 lds r23, 0x0073
456: 0f 2e mov r0, r31
458: fc eb ldi r31, 0xBC ; 188
45a: 2f 2e mov r2, r31
45c: f1 e0 ldi r31, 0x01 ; 1
45e: 3f 2e mov r3, r31
460: f0 2d mov r31, r0
462: 50 e0 ldi r21, 0x00 ; 0
464: 40 e0 ldi r20, 0x00 ; 0
466: 61 e0 ldi r22, 0x01 ; 1
468: ef 2c mov r14, r15
46a: e3 94 inc r14
46c: f1 01 movw r30, r2
46e: 30 81 ld r19, Z
470: 56 0f add r21, r22
472: 61 81 ldd r22, Z+1 ; 0x01
474: 82 e0 ldi r24, 0x02 ; 2
476: 90 e0 ldi r25, 0x00 ; 0
478: 28 0e add r2, r24
47a: 39 1e adc r3, r25
47c: 46 0f add r20, r22
47e: 33 23 and r19, r19
480: 09 f4 brne .+2 ; 0x484 <__stack+0x25>
482: 5c c0 rjmp .+184 ; 0x53c <__stack+0xdd>
484: 64 30 cpi r22, 0x04 ; 4
486: 08 f4 brcc .+2 ; 0x48a <__stack+0x2b>
488: 59 c0 rjmp .+178 ; 0x53c <__stack+0xdd>
48a: d8 01 movw r26, r16
48c: 20 e0 ldi r18, 0x00 ; 0
48e: 8c 91 ld r24, X
490: 38 17 cp r19, r24
492: c9 f5 brne .+114 ; 0x506 <__stack+0xa7>
494: fd 01 movw r30, r26
496: 87 81 ldd r24, Z+7 ; 0x07
498: 81 30 cpi r24, 0x01 ; 1
49a: a9 f5 brne .+106 ; 0x506 <__stack+0xa7>
49c: 0f 2e mov r0, r31
49e: f6 e0 ldi r31, 0x06 ; 6
4a0: af 2e mov r10, r31
4a2: bb 24 eor r11, r11
4a4: f0 2d mov r31, r0
4a6: aa 0e add r10, r26
4a8: bb 1e adc r11, r27
4aa: 86 81 ldd r24, Z+6 ; 0x06
4ac: 99 27 eor r25, r25
4ae: 86 15 cp r24, r6
4b0: 97 05 cpc r25, r7
4b2: 49 f5 brne .+82 ; 0x506 <__stack+0xa7>
4b4: 2d 01 movw r4, r26
4b6: 08 94 sec
4b8: 41 1c adc r4, r1
4ba: 51 1c adc r5, r1
4bc: 81 81 ldd r24, Z+1 ; 0x01
4be: 88 24 eor r8, r8
4c0: 99 24 eor r9, r9
4c2: 68 94 set
4c4: 81 f8 bld r8, 1
4c6: 8a 0e add r8, r26
4c8: 9b 1e adc r9, r27
4ca: 92 81 ldd r25, Z+2 ; 0x02
4cc: 58 17 cp r21, r24
4ce: 10 f0 brcs .+4 ; 0x4d4 <__stack+0x75>
4d0: 95 17 cp r25, r21
4d2: 40 f4 brcc .+16 ; 0x4e4 <__stack+0x85>
4d4: 48 17 cp r20, r24
4d6: 10 f0 brcs .+4 ; 0x4dc <__stack+0x7d>
4d8: 94 17 cp r25, r20
4da: 20 f4 brcc .+8 ; 0x4e4 <__stack+0x85>
4dc: 85 17 cp r24, r21
4de: 98 f0 brcs .+38 ; 0x506 <__stack+0xa7>
4e0: 49 17 cp r20, r25
4e2: 88 f0 brcs .+34 ; 0x506 <__stack+0xa7>
4e4: f2 01 movw r30, r4
4e6: 50 83 st Z, r21
4e8: f4 01 movw r30, r8
4ea: 40 83 st Z, r20
4ec: fd 01 movw r30, r26
4ee: 83 81 ldd r24, Z+3 ; 0x03
4f0: 58 17 cp r21, r24
4f2: 08 f4 brcc .+2 ; 0x4f6 <__stack+0x97>
4f4: 53 83 std Z+3, r21 ; 0x03
4f6: fd 01 movw r30, r26
4f8: 85 81 ldd r24, Z+5 ; 0x05
4fa: 84 17 cp r24, r20
4fc: 08 f4 brcc .+2 ; 0x500 <__stack+0xa1>
4fe: 45 83 std Z+5, r20 ; 0x05
500: f5 01 movw r30, r10
502: f0 82 st Z, r15
504: 1b c0 rjmp .+54 ; 0x53c <__stack+0xdd>
506: 2f 5f subi r18, 0xFF ; 255
508: 28 30 cpi r18, 0x08 ; 8
50a: 09 f4 brne .+2 ; 0x50e <__stack+0xaf>
50c: 4d c0 rjmp .+154 ; 0x5a8 <__stack+0x149>
50e: 18 96 adiw r26, 0x08 ; 8
510: be cf rjmp .-132 ; 0x48e <__stack+0x2f>
512: d8 01 movw r26, r16
514: 90 e0 ldi r25, 0x00 ; 0
516: fd 01 movw r30, r26
518: 87 81 ldd r24, Z+7 ; 0x07
51a: 88 23 and r24, r24
51c: 21 f0 breq .+8 ; 0x526 <__stack+0xc7>
51e: 18 96 adiw r26, 0x08 ; 8
520: 9f 5f subi r25, 0xFF ; 255
522: 98 30 cpi r25, 0x08 ; 8
524: c1 f7 brne .-16 ; 0x516 <__stack+0xb7>
526: 3c 93 st X, r19
528: fd 01 movw r30, r26
52a: 51 83 std Z+1, r21 ; 0x01
52c: 42 83 std Z+2, r20 ; 0x02
52e: 53 83 std Z+3, r21 ; 0x03
530: f4 82 std Z+4, r15 ; 0x04
532: 45 83 std Z+5, r20 ; 0x05
534: f6 82 std Z+6, r15 ; 0x06
536: 81 e0 ldi r24, 0x01 ; 1
538: 87 83 std Z+7, r24 ; 0x07
53a: 7f 5f subi r23, 0xFF ; 255
53c: 40 3b cpi r20, 0xB0 ; 176
53e: 08 f4 brcc .+2 ; 0x542 <__stack+0xe3>
540: 95 cf rjmp .-214 ; 0x46c <__stack+0xd>
542: 70 93 73 00 sts 0x0073, r23
546: c6 01 movw r24, r12
548: 87 70 andi r24, 0x07 ; 7
54a: 90 70 andi r25, 0x00 ; 0
54c: 07 97 sbiw r24, 0x07 ; 7
54e: 01 f5 brne .+64 ; 0x590 <__stack+0x131>
550: d8 01 movw r26, r16
552: 17 96 adiw r26, 0x07 ; 7
554: 40 e0 ldi r20, 0x00 ; 0
556: 8c 91 ld r24, X
558: 81 30 cpi r24, 0x01 ; 1
55a: a1 f4 brne .+40 ; 0x584 <__stack+0x125>
55c: fd 01 movw r30, r26
55e: 31 97 sbiw r30, 0x01 ; 1
560: 90 81 ld r25, Z
562: fd 01 movw r30, r26
564: 33 97 sbiw r30, 0x03 ; 3
566: 80 81 ld r24, Z
568: 29 2f mov r18, r25
56a: 33 27 eor r19, r19
56c: f9 01 movw r30, r18
56e: e8 1b sub r30, r24
570: f1 09 sbc r31, r1
572: 33 97 sbiw r30, 0x03 ; 3
574: 3c f4 brge .+14 ; 0x584 <__stack+0x125>
576: c6 01 movw r24, r12
578: 82 1b sub r24, r18
57a: 93 0b sbc r25, r19
57c: 03 97 sbiw r24, 0x03 ; 3
57e: 14 f0 brlt .+4 ; 0x584 <__stack+0x125>
580: 1c 92 st X, r1
582: 71 50 subi r23, 0x01 ; 1
584: 4f 5f subi r20, 0xFF ; 255
586: 18 96 adiw r26, 0x08 ; 8
588: 48 30 cpi r20, 0x08 ; 8
58a: 29 f7 brne .-54 ; 0x556 <__stack+0xf7>
58c: 70 93 73 00 sts 0x0073, r23
590: e0 92 76 00 sts 0x0076, r14
594: f0 e9 ldi r31, 0x90 ; 144
596: ef 16 cp r14, r31
598: 09 f4 brne .+2 ; 0x59c <__stack+0x13d>
59a: 48 cf rjmp .-368 ; 0x42c <FrameMgr_processLine+0x10a>
59c: 80 91 72 00 lds r24, 0x0072
5a0: 82 60 ori r24, 0x02 ; 2
5a2: 80 93 72 00 sts 0x0072, r24
5a6: 04 c0 rjmp .+8 ; 0x5b0 <__stack+0x151>
5a8: 78 30 cpi r23, 0x08 ; 8
5aa: 08 f4 brcc .+2 ; 0x5ae <__stack+0x14f>
5ac: b2 cf rjmp .-156 ; 0x512 <__stack+0xb3>
5ae: c6 cf rjmp .-116 ; 0x53c <__stack+0xdd>
5b0: 21 96 adiw r28, 0x01 ; 1
5b2: 0f b6 in r0, 0x3f ; 63
5b4: f8 94 cli
5b6: de bf out 0x3e, r29 ; 62
5b8: 0f be out 0x3f, r0 ; 63
5ba: cd bf out 0x3d, r28 ; 61
5bc: df 91 pop r29
5be: cf 91 pop r28
5c0: 1f 91 pop r17
5c2: 0f 91 pop r16
5c4: ff 90 pop r15
5c6: ef 90 pop r14
5c8: df 90 pop r13
5ca: cf 90 pop r12
5cc: bf 90 pop r11
5ce: af 90 pop r10
5d0: 9f 90 pop r9
5d2: 8f 90 pop r8
5d4: 7f 90 pop r7
5d6: 6f 90 pop r6
5d8: 5f 90 pop r5
5da: 4f 90 pop r4
5dc: 3f 90 pop r3
5de: 2f 90 pop r2
5e0: 08 95 ret
000005e2 <FrameMgr_init>:
5e2: 80 e4 ldi r24, 0x40 ; 64
5e4: e8 e7 ldi r30, 0x78 ; 120
5e6: f0 e0 ldi r31, 0x00 ; 0
5e8: 11 92 st Z+, r1
5ea: 8a 95 dec r24
5ec: e9 f7 brne .-6 ; 0x5e8 <FrameMgr_init+0x6>
5ee: 08 95 ret
000005f0 <FrameMgr_acquireLine>:
5f0: 80 91 74 00 lds r24, 0x0074
5f4: 82 30 cpi r24, 0x02 ; 2
5f6: 49 f5 brne .+82 ; 0x64a <FrameMgr_acquireLine+0x5a>
5f8: 80 91 75 00 lds r24, 0x0075
5fc: 28 2f mov r18, r24
5fe: 22 0f add r18, r18
600: 80 eb ldi r24, 0xB0 ; 176
602: ec eb ldi r30, 0xBC ; 188
604: f1 e0 ldi r31, 0x01 ; 1
606: 98 2f mov r25, r24
608: 11 92 st Z+, r1
60a: 9a 95 dec r25
60c: e9 f7 brne .-6 ; 0x608 <FrameMgr_acquireLine+0x18>
60e: ec e0 ldi r30, 0x0C ; 12
610: f1 e0 ldi r31, 0x01 ; 1
612: 11 92 st Z+, r1
614: 8a 95 dec r24
616: e9 f7 brne .-6 ; 0x612 <FrameMgr_acquireLine+0x22>
618: 82 9b sbis 0x10, 2 ; 16
61a: fe cf rjmp .-4 ; 0x618 <FrameMgr_acquireLine+0x28>
61c: 82 9b sbis 0x10, 2 ; 16
61e: 07 c0 rjmp .+14 ; 0x62e <FrameMgr_acquireLine+0x3e>
620: fd cf rjmp .-6 ; 0x61c <FrameMgr_acquireLine+0x2c>
622: 90 e0 ldi r25, 0x00 ; 0
624: 84 9b sbis 0x10, 4 ; 16
626: fe cf rjmp .-4 ; 0x624 <FrameMgr_acquireLine+0x34>
628: 84 9b sbis 0x10, 4 ; 16
62a: 04 c0 rjmp .+8 ; 0x634 <FrameMgr_acquireLine+0x44>
62c: fd cf rjmp .-6 ; 0x628 <FrameMgr_acquireLine+0x38>
62e: 22 23 and r18, r18
630: c1 f7 brne .-16 ; 0x622 <FrameMgr_acquireLine+0x32>
632: 05 c0 rjmp .+10 ; 0x63e <FrameMgr_acquireLine+0x4e>
634: 91 50 subi r25, 0x01 ; 1
636: 82 2f mov r24, r18
638: 81 95 neg r24
63a: 98 17 cp r25, r24
63c: 99 f7 brne .-26 ; 0x624 <FrameMgr_acquireLine+0x34>
63e: 6c e0 ldi r22, 0x0C ; 12
640: 71 e0 ldi r23, 0x01 ; 1
642: 8c eb ldi r24, 0xBC ; 188
644: 91 e0 ldi r25, 0x01 ; 1
646: c3 d4 rcall .+2438 ; 0xfce <CamIntAsm_acquireDumpLine>
648: 08 95 ret
64a: 81 30 cpi r24, 0x01 ; 1
64c: 39 f4 brne .+14 ; 0x65c <FrameMgr_acquireLine+0x6c>
64e: 84 99 sbic 0x10, 4 ; 16
650: fe cf rjmp .-4 ; 0x64e <FrameMgr_acquireLine+0x5e>
652: 60 e0 ldi r22, 0x00 ; 0
654: 73 e0 ldi r23, 0x03 ; 3
656: 8c eb ldi r24, 0xBC ; 188
658: 91 e0 ldi r25, 0x01 ; 1
65a: 72 d4 rcall .+2276 ; 0xf40 <CamIntAsm_acquireTrackingLine>
65c: 08 95 ret
0000065e <FrameMgr_acquireFrame>:
65e: 80 91 74 00 lds r24, 0x0074
662: 81 30 cpi r24, 0x01 ; 1
664: a9 f4 brne .+42 ; 0x690 <FrameMgr_acquireFrame+0x32>
666: 10 92 76 00 sts 0x0076, r1
66a: 80 91 73 00 lds r24, 0x0073
66e: 80 93 77 00 sts 0x0077, r24
672: 10 92 73 00 sts 0x0073, r1
676: 80 e4 ldi r24, 0x40 ; 64
678: e8 e7 ldi r30, 0x78 ; 120
67a: f0 e0 ldi r31, 0x00 ; 0
67c: 11 92 st Z+, r1
67e: 8a 95 dec r24
680: e9 f7 brne .-6 ; 0x67c <FrameMgr_acquireFrame+0x1e>
682: 82 9b sbis 0x10, 2 ; 16
684: fe cf rjmp .-4 ; 0x682 <FrameMgr_acquireFrame+0x24>
686: 60 e0 ldi r22, 0x00 ; 0
688: 73 e0 ldi r23, 0x03 ; 3
68a: 8c eb ldi r24, 0xBC ; 188
68c: 91 e0 ldi r25, 0x01 ; 1
68e: 58 d4 rcall .+2224 ; 0xf40 <CamIntAsm_acquireTrackingLine>
690: 08 95 ret
00000692 <FrameMgr_dispatchEvent>:
692: 84 30 cpi r24, 0x04 ; 4
694: 19 f1 breq .+70 ; 0x6dc <FrameMgr_dispatchEvent+0x4a>
696: 85 30 cpi r24, 0x05 ; 5
698: 28 f4 brcc .+10 ; 0x6a4 <FrameMgr_dispatchEvent+0x12>
69a: 81 30 cpi r24, 0x01 ; 1
69c: 09 f1 breq .+66 ; 0x6e0 <FrameMgr_dispatchEvent+0x4e>
69e: 82 30 cpi r24, 0x02 ; 2
6a0: 41 f5 brne .+80 ; 0x6f2 <FrameMgr_dispatchEvent+0x60>
6a2: 07 c0 rjmp .+14 ; 0x6b2 <FrameMgr_dispatchEvent+0x20>
6a4: 80 38 cpi r24, 0x80 ; 128
6a6: 99 f0 breq .+38 ; 0x6ce <FrameMgr_dispatchEvent+0x3c>
6a8: 81 38 cpi r24, 0x81 ; 129
6aa: 09 f1 breq .+66 ; 0x6ee <FrameMgr_dispatchEvent+0x5c>
6ac: 80 32 cpi r24, 0x20 ; 32
6ae: 09 f5 brne .+66 ; 0x6f2 <FrameMgr_dispatchEvent+0x60>
6b0: 13 c0 rjmp .+38 ; 0x6d8 <FrameMgr_dispatchEvent+0x46>
6b2: 61 e0 ldi r22, 0x01 ; 1
6b4: 81 e1 ldi r24, 0x11 ; 17
6b6: 9b d3 rcall .+1846 ; 0xdee <CamConfig_setCamReg>
6b8: 9f d3 rcall .+1854 ; 0xdf8 <CamConfig_sendFifoCmds>
6ba: 88 ee ldi r24, 0xE8 ; 232
6bc: 93 e0 ldi r25, 0x03 ; 3
6be: e7 d3 rcall .+1998 ; 0xe8e <Utility_delay>
6c0: 10 92 75 00 sts 0x0075, r1
6c4: 82 e0 ldi r24, 0x02 ; 2
6c6: 80 93 74 00 sts 0x0074, r24
6ca: 92 df rcall .-220 ; 0x5f0 <FrameMgr_acquireLine>
6cc: 08 95 ret
6ce: 81 e0 ldi r24, 0x01 ; 1
6d0: 80 93 74 00 sts 0x0074, r24
6d4: c4 df rcall .-120 ; 0x65e <FrameMgr_acquireFrame>
6d6: 08 95 ret
6d8: cb dd rcall .-1130 ; 0x270 <FrameMgr_processFrame>
6da: 08 95 ret
6dc: c0 df rcall .-128 ; 0x65e <FrameMgr_acquireFrame>
6de: 08 95 ret
6e0: 80 91 74 00 lds r24, 0x0074
6e4: 88 23 and r24, r24
6e6: 29 f0 breq .+10 ; 0x6f2 <FrameMgr_dispatchEvent+0x60>
6e8: 84 e0 ldi r24, 0x04 ; 4
6ea: 4b dd rcall .-1386 ; 0x182 <Exec_writeEventFifo>
6ec: 08 95 ret
6ee: 10 92 74 00 sts 0x0074, r1
6f2: 08 95 ret
000006f4 <UIMgr_writeBufferToTxFifo>:
6f4: dc 01 movw r26, r24
6f6: 86 2f mov r24, r22
6f8: 66 23 and r22, r22
6fa: c9 f0 breq .+50 ; 0x72e <UIMgr_writeBufferToTxFifo+0x3a>
6fc: f8 94 cli
6fe: 61 50 subi r22, 0x01 ; 1
700: 6f 3f cpi r22, 0xFF ; 255
702: a1 f0 breq .+40 ; 0x72c <UIMgr_writeBufferToTxFifo+0x38>
704: 26 2f mov r18, r22
706: 44 e9 ldi r20, 0x94 ; 148
708: 52 e0 ldi r21, 0x02 ; 2
70a: 86 1b sub r24, r22
70c: 68 2f mov r22, r24
70e: 62 50 subi r22, 0x02 ; 2
710: 80 91 ba 00 lds r24, 0x00BA
714: fa 01 movw r30, r20
716: e8 0f add r30, r24
718: f1 1d adc r31, r1
71a: 9d 91 ld r25, X+
71c: 90 83 st Z, r25
71e: 8f 5f subi r24, 0xFF ; 255
720: 8f 73 andi r24, 0x3F ; 63
722: 80 93 ba 00 sts 0x00BA, r24
726: 21 50 subi r18, 0x01 ; 1
728: 62 17 cp r22, r18
72a: 91 f7 brne .-28 ; 0x710 <UIMgr_writeBufferToTxFifo+0x1c>
72c: 78 94 sei
72e: 08 95 ret
00000730 <UIMgr_readTxFifo>:
730: f8 94 cli
732: 90 91 bb 00 lds r25, 0x00BB
736: e4 e9 ldi r30, 0x94 ; 148
738: f2 e0 ldi r31, 0x02 ; 2
73a: e9 0f add r30, r25
73c: f1 1d adc r31, r1
73e: 80 81 ld r24, Z
740: 9f 5f subi r25, 0xFF ; 255
742: 9f 73 andi r25, 0x3F ; 63
744: 90 93 bb 00 sts 0x00BB, r25
748: 78 94 sei
74a: 99 27 eor r25, r25
74c: 08 95 ret
0000074e <UIMgr_writeTxFifo>:
74e: f8 94 cli
750: 90 91 ba 00 lds r25, 0x00BA
754: e4 e9 ldi r30, 0x94 ; 148
756: f2 e0 ldi r31, 0x02 ; 2
758: e9 0f add r30, r25
75a: f1 1d adc r31, r1
75c: 80 83 st Z, r24
75e: 9f 5f subi r25, 0xFF ; 255
760: 9f 73 andi r25, 0x3F ; 63
762: 90 93 ba 00 sts 0x00BA, r25
766: 78 94 sei
768: 08 95 ret
0000076a <UIMgr_flushTxBuffer>:
76a: 90 91 ba 00 lds r25, 0x00BA
76e: 80 91 bb 00 lds r24, 0x00BB
772: 98 17 cp r25, r24
774: 41 f0 breq .+16 ; 0x786 <UIMgr_flushTxBuffer+0x1c>
776: dc df rcall .-72 ; 0x730 <UIMgr_readTxFifo>
778: f5 d1 rcall .+1002 ; 0xb64 <UartInt_txByte>
77a: 90 91 ba 00 lds r25, 0x00BA
77e: 80 91 bb 00 lds r24, 0x00BB
782: 98 17 cp r25, r24
784: c1 f7 brne .-16 ; 0x776 <UIMgr_flushTxBuffer+0xc>
786: 08 95 ret
00000788 <UIMgr_txBuffer>:
788: 0f 93 push r16
78a: 1f 93 push r17
78c: cf 93 push r28
78e: df 93 push r29
790: ec 01 movw r28, r24
792: 86 2f mov r24, r22
794: 61 50 subi r22, 0x01 ; 1
796: 6f 3f cpi r22, 0xFF ; 255
798: 49 f0 breq .+18 ; 0x7ac <UIMgr_txBuffer+0x24>
79a: 16 2f mov r17, r22
79c: 86 1b sub r24, r22
79e: 08 2f mov r16, r24
7a0: 02 50 subi r16, 0x02 ; 2
7a2: 89 91 ld r24, Y+
7a4: df d1 rcall .+958 ; 0xb64 <UartInt_txByte>
7a6: 11 50 subi r17, 0x01 ; 1
7a8: 01 17 cp r16, r17
7aa: d9 f7 brne .-10 ; 0x7a2 <UIMgr_txBuffer+0x1a>
7ac: df 91 pop r29
7ae: cf 91 pop r28
7b0: 1f 91 pop r17
7b2: 0f 91 pop r16
7b4: 08 95 ret
000007b6 <UIMgr_transmitPendingData>:
7b6: 90 91 ba 00 lds r25, 0x00BA
7ba: 80 91 bb 00 lds r24, 0x00BB
7be: 98 17 cp r25, r24
7c0: 11 f0 breq .+4 ; 0x7c6 <UIMgr_transmitPendingData+0x10>
7c2: b6 df rcall .-148 ; 0x730 <UIMgr_readTxFifo>
7c4: cf d1 rcall .+926 ; 0xb64 <UartInt_txByte>
7c6: 08 95 ret
000007c8 <UIMgr_convertTokenToCmd>:
7c8: 90 91 bf 00 lds r25, 0x00BF
7cc: 90 35 cpi r25, 0x50 ; 80
7ce: 41 f4 brne .+16 ; 0x7e0 <UIMgr_convertTokenToCmd+0x18>
7d0: 80 91 c0 00 lds r24, 0x00C0
7d4: 87 34 cpi r24, 0x47 ; 71
7d6: 09 f5 brne .+66 ; 0x81a <UIMgr_convertTokenToCmd+0x52>
7d8: 81 e0 ldi r24, 0x01 ; 1
7da: 80 93 62 00 sts 0x0062, r24
7de: 48 c0 rjmp .+144 ; 0x870 <UIMgr_convertTokenToCmd+0xa8>
7e0: 97 34 cpi r25, 0x47 ; 71
7e2: 39 f4 brne .+14 ; 0x7f2 <UIMgr_convertTokenToCmd+0x2a>
7e4: 80 91 c0 00 lds r24, 0x00C0
7e8: 86 35 cpi r24, 0x56 ; 86
7ea: 09 f5 brne .+66 ; 0x82e <UIMgr_convertTokenToCmd+0x66>
7ec: 10 92 62 00 sts 0x0062, r1
7f0: 3f c0 rjmp .+126 ; 0x870 <UIMgr_convertTokenToCmd+0xa8>
7f2: 94 34 cpi r25, 0x44 ; 68
7f4: 41 f4 brne .+16 ; 0x806 <UIMgr_convertTokenToCmd+0x3e>
7f6: 80 91 c0 00 lds r24, 0x00C0
7fa: 86 34 cpi r24, 0x46 ; 70
7fc: 11 f5 brne .+68 ; 0x842 <UIMgr_convertTokenToCmd+0x7a>
7fe: 83 e0 ldi r24, 0x03 ; 3
800: 80 93 62 00 sts 0x0062, r24
804: 35 c0 rjmp .+106 ; 0x870 <UIMgr_convertTokenToCmd+0xa8>
806: 93 34 cpi r25, 0x43 ; 67
808: 41 f4 brne .+16 ; 0x81a <UIMgr_convertTokenToCmd+0x52>
80a: 80 91 c0 00 lds r24, 0x00C0
80e: 82 35 cpi r24, 0x52 ; 82
810: 11 f5 brne .+68 ; 0x856 <UIMgr_convertTokenToCmd+0x8e>
812: 82 e0 ldi r24, 0x02 ; 2
814: 80 93 62 00 sts 0x0062, r24
818: 2b c0 rjmp .+86 ; 0x870 <UIMgr_convertTokenToCmd+0xa8>
81a: 95 34 cpi r25, 0x45 ; 69
81c: 41 f4 brne .+16 ; 0x82e <UIMgr_convertTokenToCmd+0x66>
81e: 80 91 c0 00 lds r24, 0x00C0
822: 84 35 cpi r24, 0x54 ; 84
824: 11 f5 brne .+68 ; 0x86a <UIMgr_convertTokenToCmd+0xa2>
826: 84 e0 ldi r24, 0x04 ; 4
828: 80 93 62 00 sts 0x0062, r24
82c: 21 c0 rjmp .+66 ; 0x870 <UIMgr_convertTokenToCmd+0xa8>
82e: 93 35 cpi r25, 0x53 ; 83
830: 41 f4 brne .+16 ; 0x842 <UIMgr_convertTokenToCmd+0x7a>
832: 80 91 c0 00 lds r24, 0x00C0
836: 8d 34 cpi r24, 0x4D ; 77
838: c1 f4 brne .+48 ; 0x86a <UIMgr_convertTokenToCmd+0xa2>
83a: 86 e0 ldi r24, 0x06 ; 6
83c: 80 93 62 00 sts 0x0062, r24
840: 17 c0 rjmp .+46 ; 0x870 <UIMgr_convertTokenToCmd+0xa8>
842: 94 34 cpi r25, 0x44 ; 68
844: 41 f4 brne .+16 ; 0x856 <UIMgr_convertTokenToCmd+0x8e>
846: 80 91 c0 00 lds r24, 0x00C0
84a: 84 35 cpi r24, 0x54 ; 84
84c: 71 f4 brne .+28 ; 0x86a <UIMgr_convertTokenToCmd+0xa2>
84e: 85 e0 ldi r24, 0x05 ; 5
850: 80 93 62 00 sts 0x0062, r24
854: 0d c0 rjmp .+26 ; 0x870 <UIMgr_convertTokenToCmd+0xa8>
856: 92 35 cpi r25, 0x52 ; 82
858: 41 f4 brne .+16 ; 0x86a <UIMgr_convertTokenToCmd+0xa2>
85a: 80 91 c0 00 lds r24, 0x00C0
85e: 83 35 cpi r24, 0x53 ; 83
860: 21 f4 brne .+8 ; 0x86a <UIMgr_convertTokenToCmd+0xa2>
862: 87 e0 ldi r24, 0x07 ; 7
864: 80 93 62 00 sts 0x0062, r24
868: 03 c0 rjmp .+6 ; 0x870 <UIMgr_convertTokenToCmd+0xa8>
86a: 89 e0 ldi r24, 0x09 ; 9
86c: 80 93 62 00 sts 0x0062, r24
870: 83 e0 ldi r24, 0x03 ; 3
872: ef eb ldi r30, 0xBF ; 191
874: f0 e0 ldi r31, 0x00 ; 0
876: 11 92 st Z+, r1
878: 8a 95 dec r24
87a: e9 f7 brne .-6 ; 0x876 <UIMgr_convertTokenToCmd+0xae>
87c: 10 92 be 00 sts 0x00BE, r1
880: 10 92 bd 00 sts 0x00BD, r1
884: 08 95 ret
00000886 <UIMgr_init>:
886: 10 92 bf 00 sts 0x00BF, r1
88a: 10 92 c0 00 sts 0x00C0, r1
88e: 10 92 c1 00 sts 0x00C1, r1
892: 10 92 c2 00 sts 0x00C2, r1
896: 80 e4 ldi r24, 0x40 ; 64
898: e3 ec ldi r30, 0xC3 ; 195
89a: f0 e0 ldi r31, 0x00 ; 0
89c: 98 2f mov r25, r24
89e: 11 92 st Z+, r1
8a0: 9a 95 dec r25
8a2: e9 f7 brne .-6 ; 0x89e <UIMgr_init+0x18>
8a4: e4 e9 ldi r30, 0x94 ; 148
8a6: f2 e0 ldi r31, 0x02 ; 2
8a8: 11 92 st Z+, r1
8aa: 8a 95 dec r24
8ac: e9 f7 brne .-6 ; 0x8a8 <UIMgr_init+0x22>
8ae: 80 e2 ldi r24, 0x20 ; 32
8b0: e4 e7 ldi r30, 0x74 ; 116
8b2: f2 e0 ldi r31, 0x02 ; 2
8b4: 11 92 st Z+, r1
8b6: 8a 95 dec r24
8b8: e9 f7 brne .-6 ; 0x8b4 <UIMgr_init+0x2e>
8ba: 08 95 ret
000008bc <UIMgr_convertTokenToValue>:
8bc: 8f eb ldi r24, 0xBF ; 191
8be: 90 e0 ldi r25, 0x00 ; 0
8c0: b0 d3 rcall .+1888 ; 0x1022 <atoi>
8c2: 9c 01 movw r18, r24
8c4: 8f 3f cpi r24, 0xFF ; 255
8c6: 91 05 cpc r25, r1
8c8: 69 f0 breq .+26 ; 0x8e4 <UIMgr_convertTokenToValue+0x28>
8ca: 60 f0 brcs .+24 ; 0x8e4 <UIMgr_convertTokenToValue+0x28>
8cc: 89 e0 ldi r24, 0x09 ; 9
8ce: 80 93 62 00 sts 0x0062, r24
8d2: 80 91 bc 00 lds r24, 0x00BC
8d6: e3 ec ldi r30, 0xC3 ; 195
8d8: f0 e0 ldi r31, 0x00 ; 0
8da: e8 0f add r30, r24
8dc: f1 1d adc r31, r1
8de: 8f ef ldi r24, 0xFF ; 255
8e0: 80 83 st Z, r24
8e2: 07 c0 rjmp .+14 ; 0x8f2 <UIMgr_convertTokenToValue+0x36>
8e4: 80 91 bc 00 lds r24, 0x00BC
8e8: e3 ec ldi r30, 0xC3 ; 195
8ea: f0 e0 ldi r31, 0x00 ; 0
8ec: e8 0f add r30, r24
8ee: f1 1d adc r31, r1
8f0: 20 83 st Z, r18
8f2: 83 e0 ldi r24, 0x03 ; 3
8f4: ef eb ldi r30, 0xBF ; 191
8f6: f0 e0 ldi r31, 0x00 ; 0
8f8: 11 92 st Z+, r1
8fa: 8a 95 dec r24
8fc: e9 f7 brne .-6 ; 0x8f8 <UIMgr_convertTokenToValue+0x3c>
8fe: 10 92 be 00 sts 0x00BE, r1
902: 10 92 bd 00 sts 0x00BD, r1
906: 08 95 ret
00000908 <UIMgr_processReceivedData>:
908: ff 92 push r15
90a: 0f 93 push r16
90c: 1f 93 push r17
90e: cf 93 push r28
910: df 93 push r29
912: 0f 2e mov r0, r31
914: f9 e0 ldi r31, 0x09 ; 9
916: ff 2e mov r15, r31
918: f0 2d mov r31, r0
91a: ff c0 rjmp .+510 ; 0xb1a <UIMgr_processReceivedData+0x212>
91c: f8 94 cli
91e: e2 2f mov r30, r18
920: ff 27 eor r31, r31
922: ec 58 subi r30, 0x8C ; 140
924: fd 4f sbci r31, 0xFD ; 253
926: 90 81 ld r25, Z
928: 82 2f mov r24, r18
92a: 8f 5f subi r24, 0xFF ; 255
92c: 8f 71 andi r24, 0x1F ; 31
92e: 80 93 b9 00 sts 0x00B9, r24
932: 78 94 sei
934: 9d 30 cpi r25, 0x0D ; 13
936: 09 f0 breq .+2 ; 0x93a <UIMgr_processReceivedData+0x32>
938: b1 c0 rjmp .+354 ; 0xa9c <UIMgr_processReceivedData+0x194>
93a: 80 91 bc 00 lds r24, 0x00BC
93e: 88 23 and r24, r24
940: 11 f4 brne .+4 ; 0x946 <UIMgr_processReceivedData+0x3e>
942: 42 df rcall .-380 ; 0x7c8 <UIMgr_convertTokenToCmd>
944: 06 c0 rjmp .+12 ; 0x952 <UIMgr_processReceivedData+0x4a>
946: ba df rcall .-140 ; 0x8bc <UIMgr_convertTokenToValue>
948: 80 91 bc 00 lds r24, 0x00BC
94c: 8f 5f subi r24, 0xFF ; 255
94e: 80 93 bc 00 sts 0x00BC, r24
952: 84 e6 ldi r24, 0x64 ; 100
954: 90 e0 ldi r25, 0x00 ; 0
956: 9b d2 rcall .+1334 ; 0xe8e <Utility_delay>
958: 80 91 62 00 lds r24, 0x0062
95c: 88 50 subi r24, 0x08 ; 8
95e: 82 30 cpi r24, 0x02 ; 2
960: 58 f4 brcc .+22 ; 0x978 <UIMgr_processReceivedData+0x70>
962: 8e e4 ldi r24, 0x4E ; 78
964: f4 de rcall .-536 ; 0x74e <UIMgr_writeTxFifo>
966: 83 e4 ldi r24, 0x43 ; 67
968: f2 de rcall .-540 ; 0x74e <UIMgr_writeTxFifo>
96a: 8b e4 ldi r24, 0x4B ; 75
96c: f0 de rcall .-544 ; 0x74e <UIMgr_writeTxFifo>
96e: 8d e0 ldi r24, 0x0D ; 13
970: ee de rcall .-548 ; 0x74e <UIMgr_writeTxFifo>
972: 80 e9 ldi r24, 0x90 ; 144
974: 06 dc rcall .-2036 ; 0x182 <Exec_writeEventFifo>
976: 89 c0 rjmp .+274 ; 0xa8a <UIMgr_processReceivedData+0x182>
978: 81 e4 ldi r24, 0x41 ; 65
97a: e9 de rcall .-558 ; 0x74e <UIMgr_writeTxFifo>
97c: 83 e4 ldi r24, 0x43 ; 67
97e: e7 de rcall .-562 ; 0x74e <UIMgr_writeTxFifo>
980: 8b e4 ldi r24, 0x4B ; 75
982: e5 de rcall .-566 ; 0x74e <UIMgr_writeTxFifo>
984: 8d e0 ldi r24, 0x0D ; 13
986: e3 de rcall .-570 ; 0x74e <UIMgr_writeTxFifo>
988: 80 e9 ldi r24, 0x90 ; 144
98a: fb db rcall .-2058 ; 0x182 <Exec_writeEventFifo>
98c: 80 91 62 00 lds r24, 0x0062
990: 81 30 cpi r24, 0x01 ; 1
992: 09 f4 brne .+2 ; 0x996 <UIMgr_processReceivedData+0x8e>
994: 7a c0 rjmp .+244 ; 0xa8a <UIMgr_processReceivedData+0x182>
996: 88 23 and r24, r24
998: 71 f4 brne .+28 ; 0x9b6 <UIMgr_processReceivedData+0xae>
99a: 80 91 63 00 lds r24, 0x0063
99e: 88 23 and r24, r24
9a0: 09 f4 brne .+2 ; 0x9a4 <UIMgr_processReceivedData+0x9c>
9a2: 73 c0 rjmp .+230 ; 0xa8a <UIMgr_processReceivedData+0x182>
9a4: c3 e6 ldi r28, 0x63 ; 99
9a6: d0 e0 ldi r29, 0x00 ; 0
9a8: 21 96 adiw r28, 0x01 ; 1
9aa: d1 de rcall .-606 ; 0x74e <UIMgr_writeTxFifo>
9ac: 88 81 ld r24, Y
9ae: 88 23 and r24, r24
9b0: 09 f4 brne .+2 ; 0x9b4 <UIMgr_processReceivedData+0xac>
9b2: 6b c0 rjmp .+214 ; 0xa8a <UIMgr_processReceivedData+0x182>
9b4: f9 cf rjmp .-14 ; 0x9a8 <UIMgr_processReceivedData+0xa0>
9b6: 87 30 cpi r24, 0x07 ; 7
9b8: 11 f4 brne .+4 ; 0x9be <UIMgr_processReceivedData+0xb6>
9ba: a1 db rcall .-2238 ; 0xfe <CamInt_resetCam>
9bc: 66 c0 rjmp .+204 ; 0xa8a <UIMgr_processReceivedData+0x182>
9be: 83 30 cpi r24, 0x03 ; 3
9c0: 31 f4 brne .+12 ; 0x9ce <UIMgr_processReceivedData+0xc6>
9c2: 84 e6 ldi r24, 0x64 ; 100
9c4: 90 e0 ldi r25, 0x00 ; 0
9c6: 63 d2 rcall .+1222 ; 0xe8e <Utility_delay>
9c8: 82 e0 ldi r24, 0x02 ; 2
9ca: db db rcall .-2122 ; 0x182 <Exec_writeEventFifo>
9cc: 5e c0 rjmp .+188 ; 0xa8a <UIMgr_processReceivedData+0x182>
9ce: 82 30 cpi r24, 0x02 ; 2
9d0: 99 f4 brne .+38 ; 0x9f8 <UIMgr_processReceivedData+0xf0>
9d2: 80 91 bc 00 lds r24, 0x00BC
9d6: 82 30 cpi r24, 0x02 ; 2
9d8: 68 f0 brcs .+26 ; 0x9f4 <UIMgr_processReceivedData+0xec>
9da: 11 e0 ldi r17, 0x01 ; 1
9dc: e1 2f mov r30, r17
9de: ff 27 eor r31, r31
9e0: ed 53 subi r30, 0x3D ; 61
9e2: ff 4f sbci r31, 0xFF ; 255
9e4: 61 81 ldd r22, Z+1 ; 0x01
9e6: 80 81 ld r24, Z
9e8: 02 d2 rcall .+1028 ; 0xdee <CamConfig_setCamReg>
9ea: 1e 5f subi r17, 0xFE ; 254
9ec: 80 91 bc 00 lds r24, 0x00BC
9f0: 18 17 cp r17, r24
9f2: a0 f3 brcs .-24 ; 0x9dc <UIMgr_processReceivedData+0xd4>
9f4: 01 d2 rcall .+1026 ; 0xdf8 <CamConfig_sendFifoCmds>
9f6: 49 c0 rjmp .+146 ; 0xa8a <UIMgr_processReceivedData+0x182>
9f8: 84 30 cpi r24, 0x04 ; 4
9fa: 31 f4 brne .+12 ; 0xa08 <UIMgr_processReceivedData+0x100>
9fc: 84 e6 ldi r24, 0x64 ; 100
9fe: 90 e0 ldi r25, 0x00 ; 0
a00: 46 d2 rcall .+1164 ; 0xe8e <Utility_delay>
a02: 80 e8 ldi r24, 0x80 ; 128
a04: be db rcall .-2180 ; 0x182 <Exec_writeEventFifo>
a06: 41 c0 rjmp .+130 ; 0xa8a <UIMgr_processReceivedData+0x182>
a08: 85 30 cpi r24, 0x05 ; 5
a0a: 19 f4 brne .+6 ; 0xa12 <UIMgr_processReceivedData+0x10a>
a0c: 81 e8 ldi r24, 0x81 ; 129
a0e: b9 db rcall .-2190 ; 0x182 <Exec_writeEventFifo>
a10: 3c c0 rjmp .+120 ; 0xa8a <UIMgr_processReceivedData+0x182>
a12: 86 30 cpi r24, 0x06 ; 6
a14: 09 f0 breq .+2 ; 0xa18 <UIMgr_processReceivedData+0x110>
a16: 39 c0 rjmp .+114 ; 0xa8a <UIMgr_processReceivedData+0x182>
a18: 80 91 bc 00 lds r24, 0x00BC
a1c: 88 23 and r24, r24
a1e: 09 f4 brne .+2 ; 0xa22 <UIMgr_processReceivedData+0x11a>
a20: 34 c0 rjmp .+104 ; 0xa8a <UIMgr_processReceivedData+0x182>
a22: 40 e0 ldi r20, 0x00 ; 0
a24: 03 ec ldi r16, 0xC3 ; 195
a26: 10 e0 ldi r17, 0x00 ; 0
a28: 60 e0 ldi r22, 0x00 ; 0
a2a: 73 e0 ldi r23, 0x03 ; 3
a2c: 84 2f mov r24, r20
a2e: 99 27 eor r25, r25
a30: 9c 01 movw r18, r24
a32: 2f 5f subi r18, 0xFF ; 255
a34: 3f 4f sbci r19, 0xFF ; 255
a36: f9 01 movw r30, r18
a38: e0 0f add r30, r16
a3a: f1 1f adc r31, r17
a3c: e0 81 ld r30, Z
a3e: ec 01 movw r28, r24
a40: c6 0f add r28, r22
a42: d7 1f adc r29, r23
a44: e8 83 st Y, r30
uint8_t
eeprom_read_byte (const uint8_t *addr)
{
uint8_t result;
asm volatile
a46: d9 01 movw r26, r18
a48: 20 d3 rcall .+1600 ; 0x108a <__eeprom_read_byte_1C1D1E>
a4a: 80 2d mov r24, r0
static unsigned char tokenBuffer[MAX_TOKEN_COUNT];
static UIMgr_Cmd_t receivedCmd = noCmd;
static unsigned char AVRcamVersion[] = "AVRcam v1.4\r";
/* we can't just call acquire line again here,
since we don't know if we need to acquire another
line or not (it depends on the FrameMgr to figure
this out) */
}
if (fastEventBitmask & FEV_PROCESS_LINE_COMPLETE)
1a4: 80 91 72 00 lds r24, 0x0072
1a8: 81 ff sbrs r24, 1
1aa: 08 c0 rjmp .+16 ; 0x1bc
{
DISABLE_INTS();
1ac: f8 94 cli
fastEventBitmask &= ~FEV_PROCESS_LINE_COMPLETE;
1ae: 80 91 72 00 lds r24, 0x0072
1b2: 8d 7f andi r24, 0xFD ; 253
1b4: 80 93 72 00 sts 0x0072, r24
ENABLE_INTS();
1b8: 78 94 sei
FrameMgr_acquireLine();
1ba: b9 d0 rcall .+370 ; 0x32e
}
}
if (IS_DATA_IN_EVENT_FIFO() == TRUE)
1bc: 90 91 70 00 lds r25, 0x0070
1c0: 80 91 71 00 lds r24, 0x0071
1c4: 98 17 cp r25, r24
1c6: f9 f2 breq .-66 ; 0x186
{
eventGenerated = Exec_readEventFifo();
1c8: 32 d0 rcall .+100 ; 0x22e
1ca: c8 2f mov r28, r24
switch(eventGenerated)
1cc: 99 27 eor r25, r25
1ce: 80 31 cpi r24, 0x10 ; 16
1d0: 91 05 cpc r25, r1
1d2: 11 f1 breq .+68 ; 0x218
1d4: 81 31 cpi r24, 0x11 ; 17
1d6: 91 05 cpc r25, r1
1d8: 7c f4 brge .+30 ; 0x1f8
1da: 82 30 cpi r24, 0x02 ; 2
1dc: 91 05 cpc r25, r1
1de: 09 f1 breq .+66 ; 0x222
1e0: 83 30 cpi r24, 0x03 ; 3
1e2: 91 05 cpc r25, r1
1e4: 1c f4 brge .+6 ; 0x1ec
1e6: 01 97 sbiw r24, 0x01 ; 1
1e8: d1 f0 breq .+52 ; 0x21e
1ea: cd cf rjmp .-102 ; 0x186
1ec: 84 30 cpi r24, 0x04 ; 4
1ee: 91 05 cpc r25, r1
1f0: c1 f0 breq .+48 ; 0x222
1f2: 08 97 sbiw r24, 0x08 ; 8
1f4: b1 f0 breq .+44 ; 0x222
1f6: c7 cf rjmp .-114 ; 0x186
1f8: 80 38 cpi r24, 0x80 ; 128
1fa: 91 05 cpc r25, r1
1fc: 91 f0 breq .+36 ; 0x222
1fe: 81 38 cpi r24, 0x81 ; 129
200: 91 05 cpc r25, r1
202: 1c f4 brge .+6 ; 0x20a
204: 80 97 sbiw r24, 0x20 ; 32
206: 69 f0 breq .+26 ; 0x222
208: be cf rjmp .-132 ; 0x186
20a: 81 38 cpi r24, 0x81 ; 129
20c: 91 05 cpc r25, r1
20e: 49 f0 breq .+18 ; 0x222
210: 80 39 cpi r24, 0x90 ; 144
212: 91 05 cpc r25, r1
214: 49 f0 breq .+18 ; 0x228
216: b7 cf rjmp .-146 ; 0x186
{
case (EV_DUMP_FRAME):
FrameMgr_dispatchEvent(eventGenerated);
break;
case (EV_ENABLE_TRACKING):
FrameMgr_dispatchEvent(eventGenerated);
break;
case (EV_DISABLE_TRACKING):
FrameMgr_dispatchEvent(eventGenerated);
break;
case (EV_ACQUIRE_LINE_COMPLETE):
FrameMgr_dispatchEvent(eventGenerated);
218: 8c 2f mov r24, r28
21a: 33 d0 rcall .+102 ; 0x282
UIMgr_dispatchEvent(eventGenerated);
21c: 05 c0 rjmp .+10 ; 0x228
break;
case (EV_ACQUIRE_FRAME_COMPLETE):
FrameMgr_dispatchEvent(eventGenerated);
break;
case (EV_PROCESS_LINE_COMPLETE):
FrameMgr_dispatchEvent(eventGenerated);
break;
case (EV_PROCESS_FRAME_COMPLETE):
FrameMgr_dispatchEvent(eventGenerated);
break;
case (EV_SERIAL_DATA_RECEIVED):
UIMgr_dispatchEvent(eventGenerated);
21e: 8c 2f mov r24, r28
220: 58 d2 rcall .+1200 ; 0x6d2
FrameMgr_dispatchEvent(eventGenerated);
222: 8c 2f mov r24, r28
224: 2e d0 rcall .+92 ; 0x282
break;
226: af cf rjmp .-162 ; 0x186
/* Local Function Declaration */
static unsigned char UIMgr_readRxFifo(void);
static unsigned char UIMgr_readTxFifo(void);
static unsigned char UIMgr_readRxFifo(void);
static void UIMgr_sendNck(void);
static void UIMgr_sendAck(void);
static void UIMgr_convertTokenToCmd(void);
static void UIMgr_convertTokenToValue(void);
static void UIMgr_executeCmd(void);
case (EV_SERIAL_DATA_PENDING_TX):
UIMgr_dispatchEvent(eventGenerated);
228: 8c 2f mov r24, r28
22a: 53 d2 rcall .+1190 ; 0x6d2
break;
22c: ac cf rjmp .-168 ; 0x186
/* Extern Variables */
unsigned char UIMgr_rxFifo[UI_MGR_RX_FIFO_SIZE];
unsigned char UIMgr_rxFifoHead=0;
unsigned char UIMgr_rxFifoTail=0;
0000022e <Exec_readEventFifo>:
default:
break;
}
}
/* toggle the debug line */
unsigned char UIMgr_txFifo[UI_MGR_TX_FIFO_SIZE];
unsigned char UIMgr_txFifoHead=0;
unsigned char UIMgr_txFifoTail=0;
}
}
/* Definitions */
#define IS_DATA_IN_TX_FIFO() (!(UIMgr_txFifoHead == UIMgr_txFifoTail))
#define IS_DATA_IN_RX_FIFO() (!(UIMgr_rxFifoHead == UIMgr_rxFifoTail))
/* MAX_EEPROM_WRITE_ATTEMPTS limits the number of writes that can be
done to a particular EEPROM cell, so that it can't possible just
write to the same cell over and over */
#define MAX_EEPROM_WRITE_ATTEMPTS 3
/***********************************************************
Function Name: Exec_readEventFifo
Function Name: UIMgr_init
Function Description: This function is responsible for
reading a single event out of the event fifo.
initializing the UIMgr module. It sets up the fifo
used to hold incoming data, etc.
Inputs: none
Outputs: unsigned char-the data read
***********************************************************/
static unsigned char Exec_readEventFifo(void)
{
unsigned char dataByte, tmpTail;
DISABLE_INTS();
22e: f8 94 cli
/* just return the current tail from the tx fifo */
dataByte = Exec_eventFifo[Exec_eventFifoTail];
230: 20 91 71 00 lds r18, 0x0071
234: 8c e6 ldi r24, 0x6C ; 108
236: 92 e0 ldi r25, 0x02 ; 2
238: fc 01 movw r30, r24
23a: e2 0f add r30, r18
23c: f1 1d adc r31, r1
23e: 90 81 ld r25, Z
tmpTail = (Exec_eventFifoTail+1) & (EXEC_EVENT_FIFO_MASK);
240: 82 2f mov r24, r18
242: 8f 5f subi r24, 0xFF ; 255
244: 87 70 andi r24, 0x07 ; 7
Exec_eventFifoTail = tmpTail;
246: 80 93 71 00 sts 0x0071, r24
ENABLE_INTS();
24a: 78 94 sei
return(dataByte);
24c: 89 2f mov r24, r25
24e: 99 27 eor r25, r25
}
250: 08 95 ret
00000252 <Exec_writeEventFifo>:
/***********************************************************
Function Name: Exec_writeEventFifo
Function Description: This function is responsible for
writing a single event to the event fifo and
updating the appropriate pointers.
Inputs: data - the byte to write to the Fifo
Outputs: none
***********************************************************/
void Exec_writeEventFifo(unsigned char event)
{
252: 38 2f mov r19, r24
unsigned char tmpHead;
DISABLE_INTS();
254: f8 94 cli
Exec_eventFifo[Exec_eventFifoHead] = event;
256: 20 91 70 00 lds r18, 0x0070
25a: 8c e6 ldi r24, 0x6C ; 108
25c: 92 e0 ldi r25, 0x02 ; 2
25e: fc 01 movw r30, r24
260: e2 0f add r30, r18
262: f1 1d adc r31, r1
264: 30 83 st Z, r19
/* now move the head up */
tmpHead = (Exec_eventFifoHead + 1) & (EXEC_EVENT_FIFO_MASK);
266: 82 2f mov r24, r18
268: 8f 5f subi r24, 0xFF ; 255
26a: 87 70 andi r24, 0x07 ; 7
Exec_eventFifoHead = tmpHead;
26c: 80 93 70 00 sts 0x0070, r24
ENABLE_INTS();
270: 78 94 sei
}
272: 08 95 ret
00000274 <FrameMgr_init>:
Outputs: none
***********************************************************/
void FrameMgr_init(void)
{
memset(trackedObjectTable,0x00,sizeof(trackedObjectTable));
274: 80 e4 ldi r24, 0x40 ; 64
276: e8 e7 ldi r30, 0x78 ; 120
278: f0 e0 ldi r31, 0x00 ; 0
27a: 11 92 st Z+, r1
27c: 8a 95 dec r24
27e: e9 f7 brne .-6 ; 0x27a
}
280: 08 95 ret
00000282 <FrameMgr_dispatchEvent>:
/***********************************************************
Function Name: FrameMgr_dispatchEvent
Function Description: This function is responsible for
taking an incoming event and performing the needed
actions with it as pertains to the FrameMgr.
Inputs: event - the generated event
Outputs: none
***********************************************************/
void FrameMgr_dispatchEvent(unsigned char event)
{
switch(event)
282: 99 27 eor r25, r25
284: 84 30 cpi r24, 0x04 ; 4
286: 91 05 cpc r25, r1
288: 51 f1 breq .+84 ; 0x2de
28a: 85 30 cpi r24, 0x05 ; 5
28c: 91 05 cpc r25, r1
28e: 34 f4 brge .+12 ; 0x29c
290: 81 30 cpi r24, 0x01 ; 1
292: 91 05 cpc r25, r1
294: 31 f1 breq .+76 ; 0x2e2
296: 02 97 sbiw r24, 0x02 ; 2
298: 71 f0 breq .+28 ; 0x2b6
{
case EV_DUMP_FRAME:
/* try re-initializing the camera before we start dumping */
CamConfig_setCamReg(0x11,0x01); /* reduce the frame rate for dumping*/
CamConfig_sendFifoCmds();
Utility_delay(1000); /* allow the new frame rate to settle */
lineCount = 0;
currentState = ST_FrameMgr_DumpingFrame;
//CamIntAsm_waitForNewDumpFrame(currentLineBuffer,previousLineBuffer);
FrameMgr_acquireLine();
break;
case EV_ENABLE_TRACKING:
currentState = ST_FrameMgr_TrackingFrame;
FrameMgr_acquireFrame();
break;
case EV_ACQUIRE_FRAME_COMPLETE:
FrameMgr_processFrame();
break;
case EV_PROCESS_FRAME_COMPLETE:
FrameMgr_acquireFrame();
break;
case EV_SERIAL_DATA_RECEIVED:
if (currentState != ST_FrameMgr_idle)
{
/* we need to go back to processing line data, since
serial data reception interrupted us....just trash the
frame and act like the frame has been processed, which
will kick off the system to wait for the next line */
PUBLISH_EVENT(EV_PROCESS_FRAME_COMPLETE);
}
break;
case EV_DISABLE_TRACKING:
/* tracking needs to be turned off */
currentState = ST_FrameMgr_idle;
break;
}
}
29a: 08 95 ret
29c: 80 38 cpi r24, 0x80 ; 128
29e: 91 05 cpc r25, r1
2a0: c1 f0 breq .+48 ; 0x2d2
2a2: 81 38 cpi r24, 0x81 ; 129
2a4: 91 05 cpc r25, r1
2a6: 1c f4 brge .+6 ; 0x2ae
2a8: 80 97 sbiw r24, 0x20 ; 32
2aa: b9 f0 breq .+46 ; 0x2da
2ac: 08 95 ret
2ae: 81 38 cpi r24, 0x81 ; 129
2b0: 91 05 cpc r25, r1
2b2: f1 f0 breq .+60 ; 0x2f0
2b4: 08 95 ret
2b6: 61 e0 ldi r22, 0x01 ; 1
2b8: 81 e1 ldi r24, 0x11 ; 17
2ba: 66 d5 rcall .+2764 ; 0xd88
2bc: 6a d5 rcall .+2772 ; 0xd92
2be: 88 ee ldi r24, 0xE8 ; 232
2c0: 93 e0 ldi r25, 0x03 ; 3
2c2: c1 d5 rcall .+2946 ; 0xe46
2c4: 10 92 73 00 sts 0x0073, r1
2c8: 82 e0 ldi r24, 0x02 ; 2
2ca: 80 93 74 00 sts 0x0074, r24
2ce: 2f d0 rcall .+94 ; 0x32e
2d0: 08 95 ret
2d2: 81 e0 ldi r24, 0x01 ; 1
2d4: 80 93 74 00 sts 0x0074, r24
2d8: 02 c0 rjmp .+4 ; 0x2de
2da: 18 d1 rcall .+560 ; 0x50c
2dc: 08 95 ret
2de: 0c d0 rcall .+24 ; 0x2f8
2e0: 08 95 ret
2e2: 80 91 74 00 lds r24, 0x0074
2e6: 88 23 and r24, r24
2e8: 29 f0 breq .+10 ; 0x2f4
2ea: 84 e0 ldi r24, 0x04 ; 4
2ec: b2 df rcall .-156 ; 0x252
2ee: 08 95 ret
2f0: 10 92 74 00 sts 0x0074, r1
2f4: 08 95 ret
2f6: 08 95 ret
000002f8 <FrameMgr_acquireFrame>:
/***********************************************************
Function Name: FrameMgr_acquireFrame
Function Description: This function is responsible for
beginning of the acquisition of a new frame of data
from the camera interface. The acquisition of this line
depends on the current state of the FrameMgr.
Inputs: none
Outputs: none
***********************************************************/
void FrameMgr_acquireFrame(void)
{
if (currentState == ST_FrameMgr_TrackingFrame)
2f8: 80 91 74 00 lds r24, 0x0074
2fc: 81 30 cpi r24, 0x01 ; 1
2fe: a9 f4 brne .+42 ; 0x32a
{
trackedLineCount = 0;
300: 10 92 77 00 sts 0x0077, r1
numPrevTrackedObjects = numCurrTrackedObjects;
304: 80 91 75 00 lds r24, 0x0075
308: 80 93 76 00 sts 0x0076, r24
numCurrTrackedObjects = 0;
30c: 10 92 75 00 sts 0x0075, r1
/* clear out the tracking table, and wait for the new frame
to start */
memset(trackedObjectTable,0x00,sizeof(trackedObjectTable));
310: 80 e4 ldi r24, 0x40 ; 64
312: e8 e7 ldi r30, 0x78 ; 120
314: f0 e0 ldi r31, 0x00 ; 0
316: 11 92 st Z+, r1
318: 8a 95 dec r24
31a: e9 f7 brne .-6 ; 0x316
//CamIntAsm_waitForNewTrackingFrame(currentLineBuffer,colorMap);
WAIT_FOR_VSYNC_HIGH();
31c: 82 9b sbis 0x10, 2 ; 16
31e: fe cf rjmp .-4 ; 0x31c
CamIntAsm_acquireTrackingLine(currentLineBuffer,colorMap);
320: 60 e0 ldi r22, 0x00 ; 0
322: 73 e0 ldi r23, 0x03 ; 3
324: 8c eb ldi r24, 0xBC ; 188
326: 91 e0 ldi r25, 0x01 ; 1
328: f0 d5 rcall .+3040 ; 0xf0a
}
}
32a: 08 95 ret
32c: 08 95 ret
0000032e <FrameMgr_acquireLine>:
/***********************************************************
Function Name: FrameMgr_acquireLine
Function Description: This function is responsible for
acquiring a line of data from the camera interface.
The acquisition of this line depends on the current
state of the FrameMgr.
Inputs: none
Outputs: none
***********************************************************/
void FrameMgr_acquireLine(void)
{
unsigned char tmpLineCount;
/* clearing out the buffers takes too long...we should
just overwrite the data here without a problem when
we start acquiring...at no point do we check for
a 0x00 value in the current or previous lineBuffers,
so it was a bit excessive :-) */
/* check which state we are in and proceed as needed */
if (currentState == ST_FrameMgr_DumpingFrame)
32e: 80 91 74 00 lds r24, 0x0074
332: 82 30 cpi r24, 0x02 ; 2
334: 11 f5 brne .+68 ; 0x37a
{
tmpLineCount = lineCount*2;
336: 80 91 73 00 lds r24, 0x0073
33a: 88 0f add r24, r24
/* clearing out the line data in dump mode is ok, and actually
is needed, since it is possible for the first dump line in
a frame to come back with the last line captured of the
last capture session...*/
memset(currentLineBuffer,0x00,LENGTH_OF_LINE_BUFFER);
33c: 90 eb ldi r25, 0xB0 ; 176
33e: ec eb ldi r30, 0xBC ; 188
340: f1 e0 ldi r31, 0x01 ; 1
342: 11 92 st Z+, r1
344: 9a 95 dec r25
346: e9 f7 brne .-6 ; 0x342
memset(previousLineBuffer,0x00,LENGTH_OF_LINE_BUFFER);
348: 90 eb ldi r25, 0xB0 ; 176
34a: ec e0 ldi r30, 0x0C ; 12
34c: f1 e0 ldi r31, 0x01 ; 1
34e: 11 92 st Z+, r1
350: 9a 95 dec r25
352: e9 f7 brne .-6 ; 0x34e
/* wait for another VSYNC so we know which frame to use
to start looking for a line to receive */
WAIT_FOR_VSYNC_HIGH();
354: 82 9b sbis 0x10, 2 ; 16
356: fe cf rjmp .-4 ; 0x354
WAIT_FOR_VSYNC_LOW();
358: 82 99 sbic 0x10, 2 ; 16
35a: fe cf rjmp .-4 ; 0x358
/* look at lineCount to determine how many HREFs we should
wait before we start sampling */
while(tmpLineCount != 0)
35c: 88 23 and r24, r24
35e: 39 f0 breq .+14 ; 0x36e
{
WAIT_FOR_HREF_HIGH();
360: 84 9b sbis 0x10, 4 ; 16
362: fe cf rjmp .-4 ; 0x360
tmpLineCount--;
364: 81 50 subi r24, 0x01 ; 1
WAIT_FOR_HREF_LOW();
366: 84 99 sbic 0x10, 4 ; 16
368: fe cf rjmp .-4 ; 0x366
36a: 88 23 and r24, r24
36c: c9 f7 brne .-14 ; 0x360
}
/* we should now be ready to sample our line...*/
CamIntAsm_acquireDumpLine(currentLineBuffer,previousLineBuffer);
36e: 6c e0 ldi r22, 0x0C ; 12
370: 71 e0 ldi r23, 0x01 ; 1
372: 8c eb ldi r24, 0xBC ; 188
374: 91 e0 ldi r25, 0x01 ; 1
376: 10 d6 rcall .+3104 ; 0xf98
}
else if (currentState == ST_FrameMgr_TrackingFrame)
{
WAIT_FOR_HREF_LOW();
CamIntAsm_acquireTrackingLine(currentLineBuffer,colorMap);
}
}
378: 08 95 ret
37a: 80 91 74 00 lds r24, 0x0074
37e: 81 30 cpi r24, 0x01 ; 1
380: 39 f4 brne .+14 ; 0x390
382: 84 99 sbic 0x10, 4 ; 16
384: fe cf rjmp .-4 ; 0x382
386: 60 e0 ldi r22, 0x00 ; 0
388: 73 e0 ldi r23, 0x03 ; 3
38a: 8c eb ldi r24, 0xBC ; 188
38c: 91 e0 ldi r25, 0x01 ; 1
38e: bd d5 rcall .+2938 ; 0xf0a
390: 08 95 ret
00000392 <FrameMgr_processLine>:
/***********************************************************
Function Name: FrameMgr_processLine
Function Description: This function is responsible for
parsing the received image line and performing either
connected region mapping (if in the Tracking state) or
sending out the raw sampled data (if in the Dumping
state).
Inputs: none
Outputs: none
***********************************************************/
void FrameMgr_processLine(void)
{
392: df 92 push r13
394: ef 92 push r14
396: ff 92 push r15
398: 0f 93 push r16
39a: 1f 93 push r17
39c: cf 93 push r28
39e: df 93 push r29
3a0: cd b7 in r28, 0x3d ; 61
3a2: de b7 in r29, 0x3e ; 62
3a4: 21 97 sbiw r28, 0x01 ; 1
3a6: 0f b6 in r0, 0x3f ; 63
3a8: f8 94 cli
3aa: de bf out 0x3e, r29 ; 62
3ac: 0f be out 0x3f, r0 ; 63
3ae: cd bf out 0x3d, r28 ; 61
unsigned char i;
volatile unsigned char dataToSend;
unsigned char *pTrackedObjectData = (unsigned char *)pCurrentTrackedObjectTable;
3b0: 00 91 60 00 lds r16, 0x0060
3b4: 10 91 61 00 lds r17, 0x0061
#ifdef DEBUG_TRACKED_LINE
unsigned char *pSendData;
unsigned char asciiBuffer[5];
unsigned char pixelCount = 0;
#endif
if (currentState == ST_FrameMgr_DumpingFrame)
3b8: 80 91 74 00 lds r24, 0x0074
3bc: 82 30 cpi r24, 0x02 ; 2
3be: 09 f0 breq .+2 ; 0x3c2
3c0: 54 c0 rjmp .+168 ; 0x46a
{
/* we want to sit in a tight loop and send the acquired data
sitting in current and previous line buffers out the serial
port...it is sent out the serial port immediately instead
of going into the UIMgr tx fifo because we can't do anything
until its sent out anyway...may as well just get it out now */
/* currentLineBuffer is getting "g" previousLineBuffer is getting "b-r" */
UartInt_txByte(0x0B); /* send the header byte */
3c2: 8b e0 ldi r24, 0x0B ; 11
3c4: cd d3 rcall .+1946 ; 0xb60
UartInt_txByte(lineCount); /* send the line count */
3c6: 80 91 73 00 lds r24, 0x0073
3ca: ca d3 rcall .+1940 ; 0xb60
for (i=0; i<NUM_PIXELS_IN_A_DUMP_LINE; i+=2)
3cc: dd 24 eor r13, r13
{
/* when a dump line is sampled, the upper byte can potentially
have garbage in it...we don't have time to mask it off as we're
sampling, so it is done here before we send it out...we also
combine the samples together so we really are sending up a
sample for line N as well as line N+1 */
dataToSend = currentLineBuffer[i];
3ce: 2d 2d mov r18, r13
3d0: 33 27 eor r19, r19
3d2: 0f 2e mov r0, r31
3d4: fc eb ldi r31, 0xBC ; 188
3d6: ef 2e mov r14, r31
3d8: f1 e0 ldi r31, 0x01 ; 1
3da: ff 2e mov r15, r31
3dc: f0 2d mov r31, r0
3de: e2 0e add r14, r18
3e0: f3 1e adc r15, r19
3e2: f7 01 movw r30, r14
3e4: 80 81 ld r24, Z
3e6: 89 83 std Y+1, r24 ; 0x01
dataToSend &= 0x0F;
3e8: 89 81 ldd r24, Y+1 ; 0x01
3ea: 8f 70 andi r24, 0x0F ; 15
3ec: 89 83 std Y+1, r24 ; 0x01
dataToSend <<= 4;
3ee: 89 81 ldd r24, Y+1 ; 0x01
3f0: 82 95 swap r24
3f2: 80 7f andi r24, 0xF0 ; 240
3f4: 89 83 std Y+1, r24 ; 0x01
dataToSend |= (previousLineBuffer[i] & 0x0F);
3f6: 89 01 movw r16, r18
3f8: 04 5f subi r16, 0xF4 ; 244
3fa: 1e 4f sbci r17, 0xFE ; 254
3fc: f8 01 movw r30, r16
3fe: 80 81 ld r24, Z
400: 98 2f mov r25, r24
402: 9f 70 andi r25, 0x0F ; 15
404: 89 81 ldd r24, Y+1 ; 0x01
406: 89 2b or r24, r25
408: 89 83 std Y+1, r24 ; 0x01
/* dataToSend should be packed now */
UartInt_txByte(dataToSend);
40a: 89 81 ldd r24, Y+1 ; 0x01
40c: a9 d3 rcall .+1874 ; 0xb60
/* flip the colors around since we are doing all G on Y and BR on UV */
dataToSend = previousLineBuffer[i+1];
40e: f8 01 movw r30, r16
410: 81 81 ldd r24, Z+1 ; 0x01
412: 89 83 std Y+1, r24 ; 0x01
dataToSend &= 0x0F;
414: 89 81 ldd r24, Y+1 ; 0x01
416: 8f 70 andi r24, 0x0F ; 15
418: 89 83 std Y+1, r24 ; 0x01
dataToSend <<= 4;
41a: 89 81 ldd r24, Y+1 ; 0x01
41c: 82 95 swap r24
41e: 80 7f andi r24, 0xF0 ; 240
420: 89 83 std Y+1, r24 ; 0x01
dataToSend |= (currentLineBuffer[i+1] & 0x0F);
422: f7 01 movw r30, r14
424: 81 81 ldd r24, Z+1 ; 0x01
426: 98 2f mov r25, r24
428: 9f 70 andi r25, 0x0F ; 15
42a: 89 81 ldd r24, Y+1 ; 0x01
42c: 89 2b or r24, r25
42e: 89 83 std Y+1, r24 ; 0x01
/* dataToSend should be packed now */
UartInt_txByte(dataToSend);
430: 89 81 ldd r24, Y+1 ; 0x01
432: 96 d3 rcall .+1836 ; 0xb60
434: f2 e0 ldi r31, 0x02 ; 2
436: df 0e add r13, r31
438: 4f ea ldi r20, 0xAF ; 175
43a: 4d 15 cp r20, r13
43c: 40 f6 brcc .-112 ; 0x3ce
}
UartInt_txByte(0x0F); /* send line end */
43e: 8f e0 ldi r24, 0x0F ; 15
440: 8f d3 rcall .+1822 ; 0xb60
/* once all the data is sent, increment out line count by 2 since
we really get 2 lines worth of pixels on each pass */
/* Update...increment only by 1, but only send 72 double-lines */
lineCount++;
442: 80 91 73 00 lds r24, 0x0073
446: 8f 5f subi r24, 0xFF ; 255
448: 80 93 73 00 sts 0x0073, r24
/* check to see if we have retrieved all of the needed lines */
if (lineCount >= 72) /* half 144, since we send two lines at a time */
44c: 88 34 cpi r24, 0x48 ; 72
44e: 08 f4 brcc .+2 ; 0x452
450: 4a c0 rjmp .+148 ; 0x4e6
{
/* we're done, so send the dump complete?...nope, just change
states and we should be fine */
lineCount = 0;
452: 10 92 73 00 sts 0x0073, r1
currentState = ST_FrameMgr_idle;
456: 10 92 74 00 sts 0x0074, r1
/* disable the PCLK counting overflow interrupt */
TIMSK &= DISABLE_PCLK_TIMER1_OVERFLOW_BITMASK;
45a: 89 b7 in r24, 0x39 ; 57
45c: 8b 7f andi r24, 0xFB ; 251
45e: 89 bf out 0x39, r24 ; 57
CamConfig_setCamReg(0x11,0x00); /* reset the frame rate to normal*/
460: 60 e0 ldi r22, 0x00 ; 0
462: 81 e1 ldi r24, 0x11 ; 17
464: 91 d4 rcall .+2338 ; 0xd88
CamConfig_sendFifoCmds();
466: 95 d4 rcall .+2346 ; 0xd92
468: 43 c0 rjmp .+134 ; 0x4f0
}
else
{
/* we have more lines to acquire in this frame, so keep on truckin...*/
PUBLISH_FAST_EVENT(FEV_PROCESS_LINE_COMPLETE);
}
}
else if (currentState == ST_FrameMgr_TrackingFrame)
46a: 80 91 74 00 lds r24, 0x0074
46e: 81 30 cpi r24, 0x01 ; 1
470: 09 f0 breq .+2 ; 0x474
472: 3e c0 rjmp .+124 ; 0x4f0
{
#ifdef DEBUG_TRACKED_LINE
/* send the received line over serial...this should only send
until a pixelCount == 176 */
pSendData = currentLineBuffer;
itoa(trackedLineCount,asciiBuffer,10);
UIMgr_txBuffer(asciiBuffer,3);
UIMgr_txBuffer(" ",1);
while(pixelCount < ACTUAL_NUM_PIXELS_IN_A_LINE)
{
memset(asciiBuffer,0x00,5);
itoa(*pSendData++,asciiBuffer,10); /* color is first byte */
UIMgr_txBuffer(asciiBuffer,3); /* 3 ascii bytes for data */
UIMgr_txBuffer(" ",1);
pixelCount += *pSendData; /* run-length is second byte */
memset(asciiBuffer,0x00,5);
itoa(*pSendData++,asciiBuffer,10);
UIMgr_txBuffer(asciiBuffer,3);
UIMgr_txBuffer(" ",1);
}
UIMgr_txBuffer("\n\r",2);
trackedLineCount++;
if (trackedLineCount == 144)
{
UIMgr_txBuffer(" FC \n\r",8);
trackedLineCount = 0;
PUBLISH_EVENT(EV_PROCESS_FRAME_COMPLETE);
}
else
{
PUBLISH_EVENT(EV_PROCESS_LINE_COMPLETE);
}
#else
/* determine if any of the RLE blocks overlap */
FrameMgr_findConnectedness();
474: a1 d0 rcall .+322 ; 0x5b8
/* we also want to remove any objects that are less than
a minimum height...we already removed portions of the
run-length that are less than MIN_PIXEL_WIDTH in the
findConnectedness() routine...doing it here instead of
a function to speed things up...this may end up slowing down the
frame rate slightly, and can be removed if this isn't needed */
/* run this routine once every 8 lines */
if ( (trackedLineCount & RUN_OBJECT_FILTER_MASK) == RUN_OBJECT_FILTER_MASK)
476: 80 91 77 00 lds r24, 0x0077
47a: 99 27 eor r25, r25
47c: 87 70 andi r24, 0x07 ; 7
47e: 90 70 andi r25, 0x00 ; 0
480: 07 97 sbiw r24, 0x07 ; 7
482: 11 f5 brne .+68 ; 0x4c8
{
for (i=0; i<MAX_TRACKED_OBJECTS; i++)
484: dd 24 eor r13, r13
{
if ( *(pTrackedObjectData + VALID_OBJECT_OFFSET) == TRUE)
486: f8 01 movw r30, r16
488: 87 81 ldd r24, Z+7 ; 0x07
48a: 81 30 cpi r24, 0x01 ; 1
48c: b9 f4 brne .+46 ; 0x4bc
{
/* check to see if the object is already in
our past...i.e., its last */
if ( (*(pTrackedObjectData + Y_LOWER_RIGHT_OFFSET) -
48e: 86 81 ldd r24, Z+6 ; 0x06
490: 28 2f mov r18, r24
492: 33 27 eor r19, r19
494: 84 81 ldd r24, Z+4 ; 0x04
496: a9 01 movw r20, r18
498: 48 1b sub r20, r24
49a: 51 09 sbc r21, r1
49c: 43 30 cpi r20, 0x03 ; 3
49e: 51 05 cpc r21, r1
4a0: 6c f4 brge .+26 ; 0x4bc
*(pTrackedObjectData + Y_UPPER_LEFT_OFFSET)) < MIN_OBJECT_TRACKING_HEIGHT)
{
/* the object is less than the minimum height...see if it is adjacent
to the current line we just processed...if so, leave it here...otherwise,
it needs to be invalidated since its too small */
if ( trackedLineCount - *(pTrackedObjectData + Y_LOWER_RIGHT_OFFSET) > 2)
4a2: 80 91 77 00 lds r24, 0x0077
4a6: 99 27 eor r25, r25
4a8: 82 1b sub r24, r18
4aa: 93 0b sbc r25, r19
4ac: 03 97 sbiw r24, 0x03 ; 3
4ae: 34 f0 brlt .+12 ; 0x4bc
{
/* invalidate the object */
*(pTrackedObjectData + VALID_OBJECT_OFFSET) = FALSE;
4b0: 17 82 std Z+7, r1 ; 0x07
numCurrTrackedObjects--;
4b2: 80 91 75 00 lds r24, 0x0075
4b6: 81 50 subi r24, 0x01 ; 1
4b8: 80 93 75 00 sts 0x0075, r24
}
}
}
pTrackedObjectData += SIZE_OF_TRACKED_OBJECT;
4bc: 08 5f subi r16, 0xF8 ; 248
4be: 1f 4f sbci r17, 0xFF ; 255
4c0: d3 94 inc r13
4c2: 57 e0 ldi r21, 0x07 ; 7
4c4: 5d 15 cp r21, r13
4c6: f8 f6 brcc .-66 ; 0x486
}
}
trackedLineCount++;
4c8: 80 91 77 00 lds r24, 0x0077
4cc: 8f 5f subi r24, 0xFF ; 255
4ce: 80 93 77 00 sts 0x0077, r24
if (trackedLineCount == ACTUAL_NUM_LINES_IN_A_FRAME)
4d2: 80 39 cpi r24, 0x90 ; 144
4d4: 41 f4 brne .+16 ; 0x4e6
{
/* an entire frame of tracking data has been acquired, so
publish an event letting the system know this fact */
PUBLISH_EVENT(EV_ACQUIRE_FRAME_COMPLETE);
4d6: 80 e2 ldi r24, 0x20 ; 32
4d8: bc de rcall .-648 ; 0x252
/* disable the PCLK counting overflow interrupt */
TIMSK &= DISABLE_PCLK_TIMER1_OVERFLOW_BITMASK;
4da: 89 b7 in r24, 0x39 ; 57
4dc: 8b 7f andi r24, 0xFB ; 251
4de: 89 bf out 0x39, r24 ; 57
trackedLineCount = 0;
4e0: 10 92 77 00 sts 0x0077, r1
4e4: 05 c0 rjmp .+10 ; 0x4f0
}
else
{
PUBLISH_FAST_EVENT(FEV_PROCESS_LINE_COMPLETE);
4e6: 80 91 72 00 lds r24, 0x0072
4ea: 82 60 ori r24, 0x02 ; 2
4ec: 80 93 72 00 sts 0x0072, r24
}
#endif
}
else
{
/* ...and here? */
}
}
4f0: 21 96 adiw r28, 0x01 ; 1
4f2: 0f b6 in r0, 0x3f ; 63
4f4: f8 94 cli
4f6: de bf out 0x3e, r29 ; 62
4f8: 0f be out 0x3f, r0 ; 63
4fa: cd bf out 0x3d, r28 ; 61
4fc: df 91 pop r29
4fe: cf 91 pop r28
500: 1f 91 pop r17
502: 0f 91 pop r16
504: ff 90 pop r15
506: ef 90 pop r14
508: df 90 pop r13
50a: 08 95 ret
0000050c <FrameMgr_processFrame>:
/***********************************************************
Function Name: FrameMgr_processFrame
Function Description: This function is responsible for
parsing the completed frame and performing all actions
needed at this level.
Inputs: none
Outputs: none
***********************************************************/
void FrameMgr_processFrame(void)
{
50c: df 92 push r13
50e: ef 92 push r14
510: ff 92 push r15
512: 0f 93 push r16
514: 1f 93 push r17
516: cf 93 push r28
518: df 93 push r29
unsigned char i,k,color;
#if DEBUG_FRAME_DATA
unsigned char asciiBuffer[5];
unsigned char j;
#endif
unsigned char *pTableData = (unsigned char *)pCurrentTrackedObjectTable;
unsigned char tmpUpperLeftX,tmpUpperLeftY,tmpLowerRightX,tmpLowerRightY;
#if DEBUG_FRAME_DATA
/* we want to send all of the currently tracked table out
the serial port for debugging */
for (i=0; i<numCurrTrackedObjects; i++)
{
UIMgr_txBuffer("----------\r\n",12);
for (j=0; j<SIZE_OF_TRACKED_OBJECT; j++)
{
memset(asciiBuffer,0x00,5);
itoa(*pTableData++,asciiBuffer,10);
UIMgr_txBuffer(asciiBuffer,3); /* 3 ascii bytes for data
+ 1 space */
UIMgr_txBuffer("\r\n",2);
}
}
/* finally, send a new line */
UIMgr_txBuffer("\r\n",2);
memset(asciiBuffer,0x00,5);
itoa(numCurrTrackedObjects,asciiBuffer,10);
UIMgr_txBuffer(asciiBuffer,3);
UIMgr_txBuffer(" PFC\r\n",5);
#else
/* we only send tracking packets if there are tracked objects */
if (numCurrTrackedObjects > 0)
51a: 80 91 75 00 lds r24, 0x0075
51e: 88 23 and r24, r24
520: 09 f4 brne .+2 ; 0x524
522: 40 c0 rjmp .+128 ; 0x5a4
{
UIMgr_writeTxFifo(0x0A); /* header byte for a tracking packet */
524: 8a e0 ldi r24, 0x0A ; 10
526: 01 d3 rcall .+1538 ; 0xb2a
/* reset the pointer */
pTableData = (unsigned char *)pCurrentTrackedObjectTable;
528: c0 91 60 00 lds r28, 0x0060
52c: d0 91 61 00 lds r29, 0x0061
UIMgr_writeTxFifo(numCurrTrackedObjects); /* num of objects tracked */
530: 80 91 75 00 lds r24, 0x0075
534: fa d2 rcall .+1524 ; 0xb2a
for (i=0; i<MAX_TRACKED_OBJECTS; i++)
536: dd 24 eor r13, r13
{
/* we only want to process objects that have their objectValid flag
set to TRUE */
if ( *(pTableData + VALID_OBJECT_OFFSET) == TRUE)
538: 8f 81 ldd r24, Y+7 ; 0x07
53a: 81 30 cpi r24, 0x01 ; 1
53c: 61 f5 brne .+88 ; 0x596
{
/* the object is valid...convert the color from bit position to value...remember,
each bit in the "color" byte corresponds to a color */
k=0;
53e: 80 e0 ldi r24, 0x00 ; 0
color = *(pTableData + COLOR_OFFSET);
540: 98 81 ld r25, Y
if (color == 128) k=0;
542: 90 38 cpi r25, 0x80 ; 128
544: d9 f0 breq .+54 ; 0x57c
else if (color == 64) k=1;
546: 90 34 cpi r25, 0x40 ; 64
548: 11 f4 brne .+4 ; 0x54e
54a: 81 e0 ldi r24, 0x01 ; 1
54c: 17 c0 rjmp .+46 ; 0x57c
else if (color == 32) k=2;
54e: 90 32 cpi r25, 0x20 ; 32
550: 11 f4 brne .+4 ; 0x556
552: 82 e0 ldi r24, 0x02 ; 2
554: 13 c0 rjmp .+38 ; 0x57c
else if (color == 16) k=3;
556: 90 31 cpi r25, 0x10 ; 16
558: 11 f4 brne .+4 ; 0x55e
55a: 83 e0 ldi r24, 0x03 ; 3
55c: 0f c0 rjmp .+30 ; 0x57c
else if (color == 8) k=4;
55e: 98 30 cpi r25, 0x08 ; 8
560: 11 f4 brne .+4 ; 0x566
562: 84 e0 ldi r24, 0x04 ; 4
564: 0b c0 rjmp .+22 ; 0x57c
else if (color == 4) k=5;
566: 94 30 cpi r25, 0x04 ; 4
568: 11 f4 brne .+4 ; 0x56e
56a: 85 e0 ldi r24, 0x05 ; 5
56c: 07 c0 rjmp .+14 ; 0x57c
else if (color == 2) k=6;
56e: 92 30 cpi r25, 0x02 ; 2
570: 11 f4 brne .+4 ; 0x576
572: 86 e0 ldi r24, 0x06 ; 6
574: 03 c0 rjmp .+6 ; 0x57c
else if (color == 1) k=7;
576: 91 30 cpi r25, 0x01 ; 1
578: 09 f4 brne .+2 ; 0x57c
57a: 87 e0 ldi r24, 0x07 ; 7
tmpUpperLeftX = *(pTableData + X_UPPER_LEFT_OFFSET); /* get the upper left X */
57c: 1b 81 ldd r17, Y+3 ; 0x03
tmpUpperLeftY = *(pTableData + Y_UPPER_LEFT_OFFSET); /* get the upper left Y */
57e: 0c 81 ldd r16, Y+4 ; 0x04
tmpLowerRightX = *(pTableData + X_LOWER_RIGHT_OFFSET); /* get the lower right X */
580: fd 80 ldd r15, Y+5 ; 0x05
tmpLowerRightY = *(pTableData + Y_LOWER_RIGHT_OFFSET); /* get the lower right Y */
582: ee 80 ldd r14, Y+6 ; 0x06
UIMgr_writeTxFifo(k); /* send the color first */
584: d2 d2 rcall .+1444 ; 0xb2a
UIMgr_writeTxFifo(tmpUpperLeftX);
586: 81 2f mov r24, r17
588: d0 d2 rcall .+1440 ; 0xb2a
UIMgr_writeTxFifo(tmpUpperLeftY);
58a: 80 2f mov r24, r16
58c: ce d2 rcall .+1436 ; 0xb2a
UIMgr_writeTxFifo(tmpLowerRightX);
58e: 8f 2d mov r24, r15
590: cc d2 rcall .+1432 ; 0xb2a
UIMgr_writeTxFifo(tmpLowerRightY);
592: 8e 2d mov r24, r14
594: ca d2 rcall .+1428 ; 0xb2a
}
/* move our pointer up to the beginning of the next object */
pTableData += SIZE_OF_TRACKED_OBJECT;
596: 28 96 adiw r28, 0x08 ; 8
598: d3 94 inc r13
59a: 87 e0 ldi r24, 0x07 ; 7
59c: 8d 15 cp r24, r13
59e: 60 f6 brcc .-104 ; 0x538
}
/* all done...send the end of tracking packets char */
UIMgr_writeTxFifo(0xFF);
5a0: 8f ef ldi r24, 0xFF ; 255
5a2: c3 d2 rcall .+1414 ; 0xb2a
}
#endif
/* the tracked object table will be cleared out right before we start
to wait for VSYNC to indicate a new frame...so it doesn't need to be
done now */
/* schedule the next action to acquire a new frame */
PUBLISH_EVENT(EV_PROCESS_FRAME_COMPLETE);
5a4: 84 e0 ldi r24, 0x04 ; 4
5a6: 55 de rcall .-854 ; 0x252
}
5a8: df 91 pop r29
5aa: cf 91 pop r28
5ac: 1f 91 pop r17
5ae: 0f 91 pop r16
5b0: ff 90 pop r15
5b2: ef 90 pop r14
5b4: df 90 pop r13
5b6: 08 95 ret
000005b8 <FrameMgr_findConnectedness>:
/***********************************************************
Function Name: FrameMgr_findConnectedness
Function Description: This function is responsible for
finding the connectedness between two particular run-
length encoded lines of pixel data. It updates the
trackingTable as needed.
Inputs: none
Outputs: none
***********************************************************/
static void FrameMgr_findConnectedness(void)
{
5b8: 1f 93 push r17
5ba: cf 93 push r28
trackedColor_t currColor;
unsigned char *pCurrLineColorInfo = currentLineBuffer;
5bc: ac eb ldi r26, 0xBC ; 188
5be: b1 e0 ldi r27, 0x01 ; 1
unsigned char *pTrackedObjectData;
register unsigned char currPixelRunStart=0;
5c0: 60 e0 ldi r22, 0x00 ; 0
register unsigned char currPixelRunFinish=0;
5c2: c6 2f mov r28, r22
register unsigned char lastLineXStart=0;
register unsigned char lastLineXFinish=0;
register unsigned char runLength=1;
5c4: 71 e0 ldi r23, 0x01 ; 1
unsigned char i;
bool_t colorConnected;
do
{
/* grab both the current color and the number of pixels
in the run...remember, pixels start at 1, not 0! */
colorConnected = FALSE;
5c6: 10 e0 ldi r17, 0x00 ; 0
currColor = *pCurrLineColorInfo++;
5c8: 5d 91 ld r21, X+
currPixelRunStart += runLength;
5ca: c7 0f add r28, r23
runLength = *pCurrLineColorInfo++;
5cc: 7d 91 ld r23, X+
currPixelRunFinish += runLength;
5ce: 67 0f add r22, r23
/* make sure that the run-length is at least as wide as
the minimum horizontal tracking width, and we care about the color */
if ( (currColor != notTracked) && (runLength > MIN_OBJECT_TRACKING_WIDTH) )
5d0: 55 23 and r21, r21
5d2: 09 f4 brne .+2 ; 0x5d6
5d4: 5d c0 rjmp .+186 ; 0x690
5d6: 74 30 cpi r23, 0x04 ; 4
5d8: 08 f4 brcc .+2 ; 0x5dc
5da: 5a c0 rjmp .+180 ; 0x690
{
/* this run contains a color we care about, so
either it will begin a new tracked object, or it
is connected to a currently tracked object...
compare it with each object in the tracking
table...we can't just look at the numTrackedObjects because
it is entirely possible that the first couple of objects could
be invalid...
NOTE: Instead of accessing each element in the trackedObjectTable
through the 'i' index, and then accessing the fields in each structure,
a pointer to each entry is established each time through the loop, followed
by accessing the elements through specified offsets. GCC seems to be
able to optimize this code much better than simply accessing the elements
of each structure in the array the more normal way...*/
pTrackedObjectData = (unsigned char *)pCurrentTrackedObjectTable;
5dc: e0 91 60 00 lds r30, 0x0060
5e0: f0 91 61 00 lds r31, 0x0061
for (i=0; i<MAX_TRACKED_OBJECTS; i++)
5e4: 41 2f mov r20, r17
{
if ( (currColor == *(pTrackedObjectData + COLOR_OFFSET)) &&
5e6: 80 81 ld r24, Z
5e8: 58 17 cp r21, r24
5ea: 51 f5 brne .+84 ; 0x640
5ec: 87 81 ldd r24, Z+7 ; 0x07
5ee: 81 30 cpi r24, 0x01 ; 1
5f0: 39 f5 brne .+78 ; 0x640
5f2: 86 81 ldd r24, Z+6 ; 0x06
5f4: 28 2f mov r18, r24
5f6: 33 27 eor r19, r19
5f8: 80 91 77 00 lds r24, 0x0077
5fc: 99 27 eor r25, r25
5fe: 01 97 sbiw r24, 0x01 ; 1
600: 28 17 cp r18, r24
602: 39 07 cpc r19, r25
604: e9 f4 brne .+58 ; 0x640
(*(pTrackedObjectData + VALID_OBJECT_OFFSET) == TRUE) &&
(*(pTrackedObjectData + Y_LOWER_RIGHT_OFFSET) == trackedLineCount - 1) )
{
/* found a color match and the object is valid...check to see if there is
connectedness */
lastLineXStart = *(pTrackedObjectData + LAST_LINE_X_START_OFFSET);
606: 81 81 ldd r24, Z+1 ; 0x01
lastLineXFinish = *(pTrackedObjectData + LAST_LINE_X_FINISH_OFFSET);
608: 92 81 ldd r25, Z+2 ; 0x02
/* Check for the 5 following types of line connectedness:
---------------------
| |
---------------------
-------------------------
| |
------------------------- */
if ( ( (currPixelRunStart >= lastLineXStart) &&
60a: c8 17 cp r28, r24
60c: 10 f0 brcs .+4 ; 0x612
60e: 9c 17 cp r25, r28
610: 40 f4 brcc .+16 ; 0x622
612: 68 17 cp r22, r24
614: 10 f0 brcs .+4 ; 0x61a
616: 96 17 cp r25, r22
618: 20 f4 brcc .+8 ; 0x622
61a: 8c 17 cp r24, r28
61c: 88 f0 brcs .+34 ; 0x640
61e: 69 17 cp r22, r25
620: 78 f0 brcs .+30 ; 0x640
(currPixelRunStart <= lastLineXFinish) ) ||
/* ---------------------
| |
---------------------
-------------------
| |
-------------------
OR
------------------------------
| |
------------------------------
---------
| |
--------- */
( (currPixelRunFinish >= lastLineXStart) &&
(currPixelRunFinish <= lastLineXFinish) ) ||
/* -------------------------------
| |
-------------------------------
-------------------------------
| |
-------------------------------
OR
-------------
| |
-------------
-------------------------------
| |
------------------------------- */
( (currPixelRunStart <= lastLineXStart) &&
(currPixelRunFinish >= lastLineXFinish) ) )
{
/* THERE IS CONNECTEDNESS...update the lastLineXStart and lastLineXFinish
data pointed to by pTrackedObjectData */
*(pTrackedObjectData + LAST_LINE_X_START_OFFSET) = currPixelRunStart;
622: c1 83 std Z+1, r28 ; 0x01
*(pTrackedObjectData + LAST_LINE_X_FINISH_OFFSET) = currPixelRunFinish;
624: 62 83 std Z+2, r22 ; 0x02
/* check if the bounding box needs to be updated */
if (*(pTrackedObjectData + X_UPPER_LEFT_OFFSET) > currPixelRunStart)
626: 83 81 ldd r24, Z+3 ; 0x03
628: c8 17 cp r28, r24
62a: 08 f4 brcc .+2 ; 0x62e
{
/* need to update the bounding box for the upper left point to
enclose this new left-most point...we never have to update the
upper left Y point, since each scan line we process moves from
top to bottom */
*(pTrackedObjectData + X_UPPER_LEFT_OFFSET) = currPixelRunStart;
62c: c3 83 std Z+3, r28 ; 0x03
}
if ( *(pTrackedObjectData + X_LOWER_RIGHT_OFFSET) < currPixelRunFinish)
62e: 85 81 ldd r24, Z+5 ; 0x05
630: 86 17 cp r24, r22
632: 08 f4 brcc .+2 ; 0x636
{
/* need to update the bounding box for the lower right X point to
enclose this new right-most point */
*(pTrackedObjectData + X_LOWER_RIGHT_OFFSET) = currPixelRunFinish;
634: 65 83 std Z+5, r22 ; 0x05
}
/* the lower right 'y' point always gets updated when connectedness is found */
*(pTrackedObjectData + Y_LOWER_RIGHT_OFFSET) = trackedLineCount;
636: 80 91 77 00 lds r24, 0x0077
63a: 86 83 std Z+6, r24 ; 0x06
/* set a flag indicating that that color run is part of another
object and thus doesn't need to be added as a new entry into the
tracking table */
colorConnected = TRUE;
63c: 11 e0 ldi r17, 0x01 ; 1
break;
63e: 04 c0 rjmp .+8 ; 0x648
}
}
/* go to the next object */
pTrackedObjectData += SIZE_OF_TRACKED_OBJECT;
640: 38 96 adiw r30, 0x08 ; 8
642: 4f 5f subi r20, 0xFF ; 255
644: 48 30 cpi r20, 0x08 ; 8
646: 78 f2 brcs .-98 ; 0x5e6
}
if (colorConnected == FALSE)
648: 11 23 and r17, r17
64a: 11 f5 brne .+68 ; 0x690
{
/* a new entry needs to be made to the tracking table, since we have
a run-length with a color, and it isn't connected to anything...but we
can only do this if there is space left in the trackedObject table */
if (numCurrTrackedObjects < MAX_TRACKED_OBJECTS)
64c: 80 91 75 00 lds r24, 0x0075
650: 88 30 cpi r24, 0x08 ; 8
652: f0 f4 brcc .+60 ; 0x690
{
/* space is available...add the object...but first we need to find an
invalid object in the object tracking table */
pTrackedObjectData = (unsigned char *)pCurrentTrackedObjectTable;
654: e0 91 60 00 lds r30, 0x0060
658: f0 91 61 00 lds r31, 0x0061
for (i=0; i<MAX_TRACKED_OBJECTS; i++)
65c: 41 2f mov r20, r17
{
if ( *(pTrackedObjectData + VALID_OBJECT_OFFSET) == FALSE) break;
65e: 87 81 ldd r24, Z+7 ; 0x07
660: 88 23 and r24, r24
662: 21 f0 breq .+8 ; 0x66c
/* if we haven't broken above, then the object must have been valid...
go ahead and move the pointer to the next object to check it */
pTrackedObjectData += SIZE_OF_TRACKED_OBJECT;
664: 38 96 adiw r30, 0x08 ; 8
666: 4f 5f subi r20, 0xFF ; 255
668: 48 30 cpi r20, 0x08 ; 8
66a: c8 f3 brcs .-14 ; 0x65e
}
/* now that we have a pointer to the tracked object to be updated, update all
the fields */
*(pTrackedObjectData + COLOR_OFFSET) = currColor; /* color */
66c: 50 83 st Z, r21
*(pTrackedObjectData + LAST_LINE_X_START_OFFSET) = currPixelRunStart; /* lastLineXStart */
66e: c1 83 std Z+1, r28 ; 0x01
*(pTrackedObjectData + LAST_LINE_X_FINISH_OFFSET) = currPixelRunFinish; /* lastLineXFinish */
670: 62 83 std Z+2, r22 ; 0x02
*(pTrackedObjectData + X_UPPER_LEFT_OFFSET) = currPixelRunStart; /* x_upperLeft */
672: c3 83 std Z+3, r28 ; 0x03
*(pTrackedObjectData + Y_UPPER_LEFT_OFFSET) = trackedLineCount; /* y_upperLeft */
674: 80 91 77 00 lds r24, 0x0077
678: 84 83 std Z+4, r24 ; 0x04
*(pTrackedObjectData + X_LOWER_RIGHT_OFFSET) = currPixelRunFinish; /* x_lowerRight */
67a: 65 83 std Z+5, r22 ; 0x05
*(pTrackedObjectData + Y_LOWER_RIGHT_OFFSET) = trackedLineCount; /* y_lowerRight */
67c: 80 91 77 00 lds r24, 0x0077
680: 86 83 std Z+6, r24 ; 0x06
*(pTrackedObjectData + VALID_OBJECT_OFFSET) = TRUE; /* objectValid flag */
682: 81 e0 ldi r24, 0x01 ; 1
684: 87 83 std Z+7, r24 ; 0x07
numCurrTrackedObjects++;
686: 80 91 75 00 lds r24, 0x0075
68a: 8f 5f subi r24, 0xFF ; 255
68c: 80 93 75 00 sts 0x0075, r24
}
}
/* move the pointer to the beginning of the next tracked object */
pTrackedObjectData += SIZE_OF_TRACKED_OBJECT;
}
} while(currPixelRunFinish < ACTUAL_NUM_PIXELS_IN_A_LINE);
690: 60 3b cpi r22, 0xB0 ; 176
692: 08 f4 brcc .+2 ; 0x696
694: 98 cf rjmp .-208 ; 0x5c6
}
696: cf 91 pop r28
698: 1f 91 pop r17
69a: 08 95 ret
0000069c <UIMgr_init>:
Outputs: none
***********************************************************/
void UIMgr_init(void)
{
memset(asciiTokenBuffer,0x00,MAX_TOKEN_LENGTH+1);
69c: 10 92 bf 00 sts 0x00BF, r1
6a0: 10 92 c0 00 sts 0x00C0, r1
6a4: 10 92 c1 00 sts 0x00C1, r1
6a8: 10 92 c2 00 sts 0x00C2, r1
memset(tokenBuffer,0x00,MAX_TOKEN_COUNT);
6ac: 80 e4 ldi r24, 0x40 ; 64
6ae: e3 ec ldi r30, 0xC3 ; 195
6b0: f0 e0 ldi r31, 0x00 ; 0
6b2: 11 92 st Z+, r1
6b4: 8a 95 dec r24
6b6: e9 f7 brne .-6 ; 0x6b2
memset(UIMgr_txFifo,0x00,UI_MGR_TX_FIFO_SIZE);
6b8: 80 e4 ldi r24, 0x40 ; 64
6ba: e4 e9 ldi r30, 0x94 ; 148
6bc: f2 e0 ldi r31, 0x02 ; 2
6be: 11 92 st Z+, r1
6c0: 8a 95 dec r24
6c2: e9 f7 brne .-6 ; 0x6be
memset(UIMgr_rxFifo,0x00,UI_MGR_RX_FIFO_SIZE);
6c4: 80 e2 ldi r24, 0x20 ; 32
6c6: e4 e7 ldi r30, 0x74 ; 116
6c8: f2 e0 ldi r31, 0x02 ; 2
6ca: 11 92 st Z+, r1
6cc: 8a 95 dec r24
6ce: e9 f7 brne .-6 ; 0x6ca
}
6d0: 08 95 ret
000006d2 <UIMgr_dispatchEvent>:
/***********************************************************
Function Name: UIMgr_dispatchEvent
Function Description: This function is responsible for
1752,15 → 1407,6
void UIMgr_dispatchEvent(unsigned char event)
{
switch(event)
6d2: 99 27 eor r25, r25
6d4: 80 31 cpi r24, 0x10 ; 16
6d6: 91 05 cpc r25, r1
6d8: 51 f0 breq .+20 ; 0x6ee
6da: 81 31 cpi r24, 0x11 ; 17
6dc: 91 05 cpc r25, r1
6de: 1c f4 brge .+6 ; 0x6e6
6e0: 01 97 sbiw r24, 0x01 ; 1
6e2: 39 f0 breq .+14 ; 0x6f2
{
case EV_ACQUIRE_LINE_COMPLETE:
UIMgr_transmitPendingData();
1775,20 → 1421,6
break;
}
}
6e4: 08 95 ret
6e6: 80 39 cpi r24, 0x90 ; 144
6e8: 91 05 cpc r25, r1
6ea: 29 f0 breq .+10 ; 0x6f6
6ec: 08 95 ret
6ee: 06 d0 rcall .+12 ; 0x6fc
6f0: 08 95 ret
6f2: 0e d0 rcall .+28 ; 0x710
6f4: 08 95 ret
6f6: e6 d1 rcall .+972 ; 0xac4
6f8: 08 95 ret
6fa: 08 95 ret
000006fc <UIMgr_transmitPendingData>:
/***********************************************************
Function Name: UIMgr_transmitPendingData
Function Description: This function is responsible for
1801,21 → 1433,11
void UIMgr_transmitPendingData(void)
{
if (IS_DATA_IN_TX_FIFO() == TRUE)
6fc: 90 91 ba 00 lds r25, 0x00BA
700: 80 91 bb 00 lds r24, 0x00BB
704: 98 17 cp r25, r24
706: 11 f0 breq .+4 ; 0x70c
{
/* data is waiting...send a single byte */
UartInt_txByte( UIMgr_readTxFifo() );
708: fe d1 rcall .+1020 ; 0xb06
70a: 2a d2 rcall .+1108 ; 0xb60
}
}
70c: 08 95 ret
70e: 08 95 ret
00000710 <UIMgr_processReceivedData>:
/***********************************************************
Function Name: UIMgr_processReceivedData
Function Description: This function is responsible for
1825,7 → 1447,6
***********************************************************/
void UIMgr_processReceivedData(void)
{
710: cf 93 push r28
unsigned char tmpData = 0;
/* still need to add a mechanism to handle token counts
1832,100 → 1453,51
that are excessive!!! FIX ME!!! */
while(IS_DATA_IN_RX_FIFO() == TRUE)
712: 90 91 b8 00 lds r25, 0x00B8
716: 80 91 b9 00 lds r24, 0x00B9
71a: 98 17 cp r25, r24
71c: 09 f4 brne .+2 ; 0x720
71e: 6f c0 rjmp .+222 ; 0x7fe
720: c9 e0 ldi r28, 0x09 ; 9
{
tmpData = UIMgr_readRxFifo();
722: df d1 rcall .+958 ; 0xae2
724: 38 2f mov r19, r24
if (tmpData == '\r')
726: 8d 30 cpi r24, 0x0D ; 13
728: 29 f5 brne .+74 ; 0x774
{
/* we have reached a token separator */
if (tokenCount == 0)
72a: 80 91 be 00 lds r24, 0x00BE
72e: 88 23 and r24, r24
730: 11 f4 brne .+4 ; 0x736
{
/* convert the command */
UIMgr_convertTokenToCmd();
732: 2c d1 rcall .+600 ; 0x98c
734: 06 c0 rjmp .+12 ; 0x742
}
else
{
/* convert a value */
UIMgr_convertTokenToValue();
736: 02 d1 rcall .+516 ; 0x93c
tokenCount++;
738: 80 91 be 00 lds r24, 0x00BE
73c: 8f 5f subi r24, 0xFF ; 255
73e: 80 93 be 00 sts 0x00BE, r24
}
/* either way, it is time to try to process the received
token list since we have reached the end of the cmd. */
Utility_delay(100);
742: 84 e6 ldi r24, 0x64 ; 100
744: 90 e0 ldi r25, 0x00 ; 0
746: 7f d3 rcall .+1790 ; 0xe46
if (receivedCmd == invalidCmd ||
748: 80 91 62 00 lds r24, 0x0062
74c: 88 50 subi r24, 0x08 ; 8
74e: 82 30 cpi r24, 0x02 ; 2
750: 20 f4 brcc .+8 ; 0x75a
receivedCmd == noCmd )
{
UIMgr_sendNck();
752: 84 d1 rcall .+776 ; 0xa5c
PUBLISH_EVENT(EV_SERIAL_DATA_PENDING_TX);
754: 80 e9 ldi r24, 0x90 ; 144
756: 7d dd rcall .-1286 ; 0x252
758: 04 c0 rjmp .+8 ; 0x762
}
else
{
UIMgr_sendAck();
75a: 77 d1 rcall .+750 ; 0xa4a
/* publish the serial data pending event, so it
will push the ACK out before we execute the cmd */
PUBLISH_EVENT(EV_SERIAL_DATA_PENDING_TX);
75c: 80 e9 ldi r24, 0x90 ; 144
75e: 79 dd rcall .-1294 ; 0x252
UIMgr_executeCmd();
760: 51 d0 rcall .+162 ; 0x804
}
/* reset any necessary data */
tokenCount = 0;
762: 10 92 be 00 sts 0x00BE, r1
memset(tokenBuffer,0x00,MAX_TOKEN_COUNT);
766: 80 e4 ldi r24, 0x40 ; 64
768: e3 ec ldi r30, 0xC3 ; 195
76a: f0 e0 ldi r31, 0x00 ; 0
76c: 11 92 st Z+, r1
76e: 8a 95 dec r24
770: e9 f7 brne .-6 ; 0x76c
772: 3e c0 rjmp .+124 ; 0x7f0
}
else if (tmpData == ' ') /* space char */
774: 80 32 cpi r24, 0x20 ; 32
776: d9 f4 brne .+54 ; 0x7ae
{
/* the end of a token has been reached */
if (tokenCount == 0)
778: 80 91 be 00 lds r24, 0x00BE
77c: 88 23 and r24, r24
77e: 11 f4 brne .+4 ; 0x784
{
UIMgr_convertTokenToCmd();
780: 05 d1 rcall .+522 ; 0x98c
tokenCount++; /* check this...why is this being incremented here??? This
782: 0f c0 rjmp .+30 ; 0x7a2
means we have received a token, with tokenCount == 0, which means it is a
command...why is this contributing to tokenCount?
This might cause the set color map command to include too much data, since
1936,77 → 1508,37
/* check to see if this token is going to push
us over the limit...if so, abort the transaction */
if (tokenCount+1 >= MAX_TOKEN_COUNT)
784: 80 91 be 00 lds r24, 0x00BE
788: 99 27 eor r25, r25
78a: 01 96 adiw r24, 0x01 ; 1
78c: 80 34 cpi r24, 0x40 ; 64
78e: 91 05 cpc r25, r1
790: 3c f0 brlt .+14 ; 0x7a0
{
/* we received too many tokens, and
need to NCK this request, since its too
large...reset everything...*/
charCount=0;
792: 10 92 bc 00 sts 0x00BC, r1
charIndex=0;
796: 10 92 bd 00 sts 0x00BD, r1
tokenCount=0;
79a: 10 92 be 00 sts 0x00BE, r1
receivedCmd = invalidCmd;
79e: 26 c0 rjmp .+76 ; 0x7ec
}
else
{
/* tokenCount is still in range...*/
UIMgr_convertTokenToValue();
7a0: cd d0 rcall .+410 ; 0x93c
tokenCount++;
7a2: 80 91 be 00 lds r24, 0x00BE
7a6: 8f 5f subi r24, 0xFF ; 255
7a8: 80 93 be 00 sts 0x00BE, r24
7ac: 21 c0 rjmp .+66 ; 0x7f0
}
}
}
else if ( (tmpData >= 'A' && tmpData <= 'Z') ||
7ae: 81 54 subi r24, 0x41 ; 65
7b0: 8a 31 cpi r24, 0x1A ; 26
7b2: 18 f0 brcs .+6 ; 0x7ba
7b4: 8f 5e subi r24, 0xEF ; 239
7b6: 8a 30 cpi r24, 0x0A ; 10
7b8: c8 f4 brcc .+50 ; 0x7ec
(tmpData >= '0' && tmpData <= '9') )
{
/* a valid range of token was received */
asciiTokenBuffer[charIndex] = tmpData;
7ba: 20 91 bd 00 lds r18, 0x00BD
7be: 82 2f mov r24, r18
7c0: 99 27 eor r25, r25
7c2: fc 01 movw r30, r24
7c4: e1 54 subi r30, 0x41 ; 65
7c6: ff 4f sbci r31, 0xFF ; 255
7c8: 30 83 st Z, r19
charCount++;
7ca: 80 91 bc 00 lds r24, 0x00BC
7ce: 98 2f mov r25, r24
7d0: 9f 5f subi r25, 0xFF ; 255
7d2: 90 93 bc 00 sts 0x00BC, r25
charIndex++;
7d6: 82 2f mov r24, r18
7d8: 8f 5f subi r24, 0xFF ; 255
7da: 80 93 bd 00 sts 0x00BD, r24
if (charCount > MAX_TOKEN_LENGTH)
7de: 94 30 cpi r25, 0x04 ; 4
7e0: 38 f0 brcs .+14 ; 0x7f0
{
/* we have received a token that cannot be handled...
set the received cmd to an invalid cmd, and wait
for the \r to process it */
receivedCmd = invalidCmd;
7e2: c0 93 62 00 sts 0x0062, r28
charIndex = 0; /* ...so we won't overwrite memory */
7e6: 10 92 bd 00 sts 0x00BD, r1
7ea: 02 c0 rjmp .+4 ; 0x7f0
}
}
else
2013,24 → 1545,13
{
/* an invalid character was received */
receivedCmd = invalidCmd;
7ec: c0 93 62 00 sts 0x0062, r28
7f0: 90 91 b8 00 lds r25, 0x00B8
7f4: 80 91 b9 00 lds r24, 0x00B9
7f8: 98 17 cp r25, r24
7fa: 09 f0 breq .+2 ; 0x7fe
7fc: 92 cf rjmp .-220 ; 0x722
}
} /* end while */
asm volatile("clt"::); /* clear out the T flag in case it wasn't
7fe: e8 94 clt
cleared already */
}
800: cf 91 pop r28
802: 08 95 ret
00000804 <UIMgr_executeCmd>:
/***********************************************************
Function Name: UIMgr_executeCmd
Function Description: This function is responsible for
2041,15 → 1562,7
***********************************************************/
static void UIMgr_executeCmd(void)
{
804: df 92 push r13
806: ef 92 push r14
808: ff 92 push r15
80a: 0f 93 push r16
80c: 1f 93 push r17
80e: cf 93 push r28
810: df 93 push r29
unsigned char i,eepromData, num_writes=0;
812: ee 24 eor r14, r14
unsigned char *pData;
unsigned char eeprom_write_succeeded = FALSE;
#if DEBUG_COLOR_MAP
2057,47 → 1570,21
#endif
if (receivedCmd == pingCmd)
814: 80 91 62 00 lds r24, 0x0062
818: 81 30 cpi r24, 0x01 ; 1
81a: 09 f4 brne .+2 ; 0x81e
81c: 87 c0 rjmp .+270 ; 0x92c
{
}
else if (receivedCmd == getVersionCmd)
81e: 88 23 and r24, r24
820: 69 f4 brne .+26 ; 0x83c
{
pData = AVRcamVersion;
822: c3 e6 ldi r28, 0x63 ; 99
824: d0 e0 ldi r29, 0x00 ; 0
while(*pData != 0)
826: 80 91 63 00 lds r24, 0x0063
82a: 88 23 and r24, r24
82c: 09 f4 brne .+2 ; 0x830
82e: 7e c0 rjmp .+252 ; 0x92c
{
UIMgr_writeTxFifo(*pData++);
830: 89 91 ld r24, Y+
832: 7b d1 rcall .+758 ; 0xb2a
834: 88 81 ld r24, Y
836: 88 23 and r24, r24
838: d9 f7 brne .-10 ; 0x830
83a: 78 c0 rjmp .+240 ; 0x92c
}
}
else if (receivedCmd == resetCameraCmd)
83c: 80 91 62 00 lds r24, 0x0062
840: 87 30 cpi r24, 0x07 ; 7
842: 11 f4 brne .+4 ; 0x848
{
CamInt_resetCam();
844: 8b dc rcall .-1770 ; 0x15c
846: 72 c0 rjmp .+228 ; 0x92c
}
else if (receivedCmd == dumpFrameCmd)
848: 80 91 62 00 lds r24, 0x0062
84c: 83 30 cpi r24, 0x03 ; 3
84e: 29 f4 brne .+10 ; 0x85a
{
/* publish the event that will indicate that
a request has come to dump a frame...this will
2107,1579 → 1594,655
it wouldn't be able to receive the serial data
as quickly as AVRcam can provide it). */
Utility_delay(100);
850: 84 e6 ldi r24, 0x64 ; 100
852: 90 e0 ldi r25, 0x00 ; 0
854: f8 d2 rcall .+1520 ; 0xe46
PUBLISH_EVENT(EV_DUMP_FRAME);
856: 82 e0 ldi r24, 0x02 ; 2
858: 28 c0 rjmp .+80 ; 0x8aa
}
else if (receivedCmd == setCameraRegsCmd)
85a: 80 91 62 00 lds r24, 0x0062
85e: 82 30 cpi r24, 0x02 ; 2
860: b1 f4 brne .+44 ; 0x88e
{
/* we need to gather the tokens and
build config cmds to be sent to the camera */
for (i=1; i<tokenCount; i+=2) /* starts at 1 since first token
862: ff 24 eor r15, r15
864: f3 94 inc r15
866: 80 91 be 00 lds r24, 0x00BE
86a: f8 16 cp r15, r24
86c: 70 f4 brcc .+28 ; 0x88a
is the CR cmd */
{
CamConfig_setCamReg(tokenBuffer[i],tokenBuffer[i+1]);
86e: 8f 2d mov r24, r15
870: 99 27 eor r25, r25
872: fc 01 movw r30, r24
874: ed 53 subi r30, 0x3D ; 61
876: ff 4f sbci r31, 0xFF ; 255
878: 61 81 ldd r22, Z+1 ; 0x01
87a: 80 81 ld r24, Z
87c: 85 d2 rcall .+1290 ; 0xd88
87e: 82 e0 ldi r24, 0x02 ; 2
880: f8 0e add r15, r24
882: 80 91 be 00 lds r24, 0x00BE
886: f8 16 cp r15, r24
888: 90 f3 brcs .-28 ; 0x86e
}
CamConfig_sendFifoCmds();
88a: 83 d2 rcall .+1286 ; 0xd92
88c: 4f c0 rjmp .+158 ; 0x92c
}
else if (receivedCmd == enableTrackingCmd)
88e: 80 91 62 00 lds r24, 0x0062
892: 84 30 cpi r24, 0x04 ; 4
894: 29 f4 brne .+10 ; 0x8a0
{
/* publish the event...again with a short delay */
Utility_delay(100);
896: 84 e6 ldi r24, 0x64 ; 100
898: 90 e0 ldi r25, 0x00 ; 0
89a: d5 d2 rcall .+1450 ; 0xe46
PUBLISH_EVENT(EV_ENABLE_TRACKING);
89c: 80 e8 ldi r24, 0x80 ; 128
89e: 05 c0 rjmp .+10 ; 0x8aa
}
else if (receivedCmd == disableTrackingCmd)
8a0: 80 91 62 00 lds r24, 0x0062
8a4: 85 30 cpi r24, 0x05 ; 5
8a6: 19 f4 brne .+6 ; 0x8ae
{
PUBLISH_EVENT(EV_DISABLE_TRACKING);
8a8: 81 e8 ldi r24, 0x81 ; 129
8aa: d3 dc rcall .-1626 ; 0x252
8ac: 3f c0 rjmp .+126 ; 0x92c
}
else if (receivedCmd == setColorMapCmd)
8ae: 80 91 62 00 lds r24, 0x0062
8b2: 86 30 cpi r24, 0x06 ; 6
8b4: d9 f5 brne .+118 ; 0x92c
{
/* copy the received tokens into the color map */
for (i=0; i<tokenCount; i++)
8b6: ff 24 eor r15, r15
8b8: 80 91 be 00 lds r24, 0x00BE
8bc: f8 16 cp r15, r24
8be: b0 f5 brcc .+108 ; 0x92c
{
colorMap[i] = tokenBuffer[i+1];
8c0: 8f 2d mov r24, r15
8c2: 99 27 eor r25, r25
8c4: 8c 01 movw r16, r24
8c6: 00 50 subi r16, 0x00 ; 0
8c8: 1d 4f sbci r17, 0xFD ; 253
8ca: fc 01 movw r30, r24
8cc: ed 53 subi r30, 0x3D ; 61
8ce: ff 4f sbci r31, 0xFF ; 255
8d0: 21 81 ldd r18, Z+1 ; 0x01
8d2: f8 01 movw r30, r16
8d4: 20 83 st Z, r18
/* write each colorMap byte to EEPROM, but only those
that changed...this will help reduce wear on the EEPROM */
eepromData = eeprom_read_byte( (unsigned char*)(i+1));
8d6: 01 96 adiw r24, 0x01 ; 1
8d8: b5 d3 rcall .+1898 ; 0x1044
8da: 98 2f mov r25, r24
if (eepromData != colorMap[i])
8dc: f8 01 movw r30, r16
8de: 80 81 ld r24, Z
8e0: 98 17 cp r25, r24
8e2: f9 f0 breq .+62 ; 0x922
a4c: e8 17 cp r30, r24
a4e: c1 f0 breq .+48 ; 0xa80 <UIMgr_processReceivedData+0x178>
void
eeprom_write_byte (uint8_t *addr,uint8_t value)
{
asm volatile (
a50: d9 01 movw r26, r18
a52: 0e 2e mov r0, r30
a54: 27 d3 rcall .+1614 ; 0x10a4 <__eeprom_write_byte_1C1D1E>
a56: d9 01 movw r26, r18
a58: 18 d3 rcall .+1584 ; 0x108a <__eeprom_read_byte_1C1D1E>
a5a: 80 2d mov r24, r0
{
/* need to actually perform the write because the
data in eeprom is different than the current colorMap */
eeprom_write_succeeded = FALSE;
8e4: dd 24 eor r13, r13
while(eeprom_write_succeeded == FALSE && num_writes < MAX_EEPROM_WRITE_ATTEMPTS)
8e6: f2 e0 ldi r31, 0x02 ; 2
8e8: fe 15 cp r31, r14
8ea: d0 f0 brcs .+52 ; 0x920
8ec: 8f 2d mov r24, r15
8ee: 99 27 eor r25, r25
8f0: 8c 01 movw r16, r24
8f2: 00 50 subi r16, 0x00 ; 0
8f4: 1d 4f sbci r17, 0xFD ; 253
8f6: ec 01 movw r28, r24
8f8: 21 96 adiw r28, 0x01 ; 1
{
eeprom_write_byte((unsigned char*)(i+1),colorMap[i]);
8fa: f8 01 movw r30, r16
8fc: 60 81 ld r22, Z
8fe: ce 01 movw r24, r28
900: ba d3 rcall .+1908 ; 0x1076
num_writes++;
902: e3 94 inc r14
eepromData = eeprom_read_byte( (unsigned char*)(i+1));
904: ce 01 movw r24, r28
906: 9e d3 rcall .+1852 ; 0x1044
908: 98 2f mov r25, r24
if (eepromData == colorMap[i])
90a: f8 01 movw r30, r16
90c: 80 81 ld r24, Z
90e: 98 17 cp r25, r24
910: 11 f4 brne .+4 ; 0x916
{
eeprom_write_succeeded = TRUE;
912: dd 24 eor r13, r13
914: d3 94 inc r13
916: dd 20 and r13, r13
918: 19 f4 brne .+6 ; 0x920
91a: f2 e0 ldi r31, 0x02 ; 2
91c: fe 15 cp r31, r14
91e: 68 f7 brcc .-38 ; 0x8fa
}
}
num_writes = 0;
920: ee 24 eor r14, r14
922: f3 94 inc r15
924: 80 91 be 00 lds r24, 0x00BE
928: f8 16 cp r15, r24
92a: 50 f2 brcs .-108 ; 0x8c0
}
}
#if DEBUG_COLOR_MAP
/* for debugging...send out the entire color map */
UIMgr_txBuffer("\r\n",2);
for (i=0; i<NUM_ELEMENTS_IN_COLOR_MAP; i++)
{
memset(asciiBuffer,0x00,5);
itoa(colorMap[i],asciiBuffer,10);
UIMgr_txBuffer(asciiBuffer,3);
UIMgr_txBuffer(" ",1);
if (i==15 || i == 31)
{
/* break up the output */
UIMgr_txBuffer("\r\n",2);
}
}
#endif
}
}
92c: df 91 pop r29
92e: cf 91 pop r28
930: 1f 91 pop r17
932: 0f 91 pop r16
934: ff 90 pop r15
936: ef 90 pop r14
938: df 90 pop r13
93a: 08 95 ret
0000093c <UIMgr_convertTokenToValue>:
/***********************************************************
Function Name: UIMgr_convertTokenToValue
Function Description: This function is responsible for
converting a received token to a hex value It will
access the asciiTokenBuffer directly, and store the
result in the appropriate token buffer.
Inputs: none
Outputs: none
***********************************************************/
static void UIMgr_convertTokenToValue(void)
{
unsigned int newValue;
newValue = atoi(asciiTokenBuffer);
93c: 8f eb ldi r24, 0xBF ; 191
93e: 90 e0 ldi r25, 0x00 ; 0
940: 55 d3 rcall .+1706 ; 0xfec
942: ac 01 movw r20, r24
if (newValue > 255)
944: 8f 3f cpi r24, 0xFF ; 255
946: 91 05 cpc r25, r1
948: 71 f0 breq .+28 ; 0x966
94a: 68 f0 brcs .+26 ; 0x966
{
/* the value is too large */
receivedCmd = invalidCmd;
94c: 89 e0 ldi r24, 0x09 ; 9
94e: 80 93 62 00 sts 0x0062, r24
tokenBuffer[tokenCount] = 0xFF; /* to indicate an error */
952: 20 91 be 00 lds r18, 0x00BE
956: 83 ec ldi r24, 0xC3 ; 195
958: 90 e0 ldi r25, 0x00 ; 0
95a: fc 01 movw r30, r24
95c: e2 0f add r30, r18
95e: f1 1d adc r31, r1
960: 8f ef ldi r24, 0xFF ; 255
962: 80 83 st Z, r24
964: 08 c0 rjmp .+16 ; 0x976
}
else
{
/* copy the value into the tokenBuffer */
tokenBuffer[tokenCount] = newValue;
966: 80 91 be 00 lds r24, 0x00BE
96a: 23 ec ldi r18, 0xC3 ; 195
96c: 30 e0 ldi r19, 0x00 ; 0
96e: f9 01 movw r30, r18
970: e8 0f add r30, r24
972: f1 1d adc r31, r1
974: 40 83 st Z, r20
}
memset(asciiTokenBuffer,0x00,MAX_TOKEN_LENGTH);
976: 83 e0 ldi r24, 0x03 ; 3
978: ef eb ldi r30, 0xBF ; 191
97a: f0 e0 ldi r31, 0x00 ; 0
97c: 11 92 st Z+, r1
97e: 8a 95 dec r24
980: e9 f7 brne .-6 ; 0x97c
charIndex = 0;
982: 10 92 bd 00 sts 0x00BD, r1
charCount = 0;
986: 10 92 bc 00 sts 0x00BC, r1
}
98a: 08 95 ret
0000098c <UIMgr_convertTokenToCmd>:
/***********************************************************
Function Name: UIMgr_convertTokenToCmd
Function Description: This function is responsible for
parsing a received 2-character command. It will
access the asciiTokenBuffer directly.
Inputs: none
Outputs: none
***********************************************************/
static void UIMgr_convertTokenToCmd(void)
{
if ( (asciiTokenBuffer[0] == 'P') &&
98c: 80 91 bf 00 lds r24, 0x00BF
990: 80 35 cpi r24, 0x50 ; 80
992: 31 f4 brne .+12 ; 0x9a0
994: 80 91 c0 00 lds r24, 0x00C0
998: 87 34 cpi r24, 0x47 ; 71
99a: 11 f4 brne .+4 ; 0x9a0
(asciiTokenBuffer[1] == 'G') )
{
/* we got a "ping" command...but we still need to see
if we are going to get the \r */
receivedCmd = pingCmd;
99c: 81 e0 ldi r24, 0x01 ; 1
99e: 48 c0 rjmp .+144 ; 0xa30
}
else if ( (asciiTokenBuffer[0] == 'G') &&
9a0: 80 91 bf 00 lds r24, 0x00BF
9a4: 87 34 cpi r24, 0x47 ; 71
9a6: 39 f4 brne .+14 ; 0x9b6
9a8: 80 91 c0 00 lds r24, 0x00C0
9ac: 86 35 cpi r24, 0x56 ; 86
9ae: 19 f4 brne .+6 ; 0x9b6
(asciiTokenBuffer[1] == 'V') )
{
/* we got the "get version" command */
receivedCmd = getVersionCmd;
9b0: 10 92 62 00 sts 0x0062, r1
9b4: 3f c0 rjmp .+126 ; 0xa34
}
else if ( (asciiTokenBuffer[0] == 'D') &&
9b6: 80 91 bf 00 lds r24, 0x00BF
9ba: 84 34 cpi r24, 0x44 ; 68
9bc: 31 f4 brne .+12 ; 0x9ca
9be: 80 91 c0 00 lds r24, 0x00C0
9c2: 86 34 cpi r24, 0x46 ; 70
9c4: 11 f4 brne .+4 ; 0x9ca
(asciiTokenBuffer[1] == 'F') )
{
/* we should go into frame dump mode */
receivedCmd = dumpFrameCmd;
9c6: 83 e0 ldi r24, 0x03 ; 3
9c8: 33 c0 rjmp .+102 ; 0xa30
}
else if ( (asciiTokenBuffer[0] == 'C') &&
9ca: 80 91 bf 00 lds r24, 0x00BF
9ce: 83 34 cpi r24, 0x43 ; 67
9d0: 31 f4 brne .+12 ; 0x9de
9d2: 80 91 c0 00 lds r24, 0x00C0
9d6: 82 35 cpi r24, 0x52 ; 82
9d8: 11 f4 brne .+4 ; 0x9de
(asciiTokenBuffer[1] == 'R') )
{
/* the user wants to set registers in the OV6620 */
receivedCmd = setCameraRegsCmd;
9da: 82 e0 ldi r24, 0x02 ; 2
9dc: 29 c0 rjmp .+82 ; 0xa30
}
else if ( (asciiTokenBuffer[0] == 'E') &&
9de: 80 91 bf 00 lds r24, 0x00BF
9e2: 85 34 cpi r24, 0x45 ; 69
9e4: 31 f4 brne .+12 ; 0x9f2
9e6: 80 91 c0 00 lds r24, 0x00C0
9ea: 84 35 cpi r24, 0x54 ; 84
9ec: 11 f4 brne .+4 ; 0x9f2
(asciiTokenBuffer[1] == 'T') )
{
/* the user wants to enable tracking */
receivedCmd = enableTrackingCmd;
9ee: 84 e0 ldi r24, 0x04 ; 4
9f0: 1f c0 rjmp .+62 ; 0xa30
}
else if ( (asciiTokenBuffer[0] == 'S') &&
9f2: 80 91 bf 00 lds r24, 0x00BF
9f6: 83 35 cpi r24, 0x53 ; 83
9f8: 31 f4 brne .+12 ; 0xa06
9fa: 80 91 c0 00 lds r24, 0x00C0
9fe: 8d 34 cpi r24, 0x4D ; 77
a00: 11 f4 brne .+4 ; 0xa06
(asciiTokenBuffer[1] == 'M') )
{
/* the user wants to set the color map */
receivedCmd = setColorMapCmd;
a02: 86 e0 ldi r24, 0x06 ; 6
a04: 15 c0 rjmp .+42 ; 0xa30
}
else if ( (asciiTokenBuffer[0] == 'D') &&
a06: 80 91 bf 00 lds r24, 0x00BF
a0a: 84 34 cpi r24, 0x44 ; 68
a0c: 31 f4 brne .+12 ; 0xa1a
a0e: 80 91 c0 00 lds r24, 0x00C0
a12: 84 35 cpi r24, 0x54 ; 84
a14: 11 f4 brne .+4 ; 0xa1a
(asciiTokenBuffer[1] == 'T') )
{
receivedCmd = disableTrackingCmd;
a16: 85 e0 ldi r24, 0x05 ; 5
a18: 0b c0 rjmp .+22 ; 0xa30
}
else if ( (asciiTokenBuffer[0] == 'R') &&
a1a: 80 91 bf 00 lds r24, 0x00BF
a1e: 82 35 cpi r24, 0x52 ; 82
a20: 31 f4 brne .+12 ; 0xa2e
a22: 80 91 c0 00 lds r24, 0x00C0
a26: 83 35 cpi r24, 0x53 ; 83
a28: 11 f4 brne .+4 ; 0xa2e
(asciiTokenBuffer[1] == 'S') )
{
receivedCmd = resetCameraCmd;
a2a: 87 e0 ldi r24, 0x07 ; 7
a2c: 01 c0 rjmp .+2 ; 0xa30
}
else
{
/* don't recognize the cmd */
receivedCmd = invalidCmd;
a2e: 89 e0 ldi r24, 0x09 ; 9
a30: 80 93 62 00 sts 0x0062, r24
}
memset(asciiTokenBuffer,0x00,MAX_TOKEN_LENGTH);
a34: 83 e0 ldi r24, 0x03 ; 3
a36: ef eb ldi r30, 0xBF ; 191
a38: f0 e0 ldi r31, 0x00 ; 0
a3a: 11 92 st Z+, r1
a3c: 8a 95 dec r24
a3e: e9 f7 brne .-6 ; 0xa3a
charIndex = 0;
a40: 10 92 bd 00 sts 0x00BD, r1
charCount = 0;
a44: 10 92 bc 00 sts 0x00BC, r1
}
a48: 08 95 ret
00000a4a <UIMgr_sendAck>:
/***********************************************************
Function Name: UIMgr_sendAck
Function Description: This function is responsible for
queuing up an ACK to be sent to the user.
Inputs: none
Outputs: none
***********************************************************/
static void UIMgr_sendAck(void)
{
UIMgr_writeTxFifo('A');
a4a: 81 e4 ldi r24, 0x41 ; 65
a4c: 6e d0 rcall .+220 ; 0xb2a
UIMgr_writeTxFifo('C');
a4e: 83 e4 ldi r24, 0x43 ; 67
a50: 6c d0 rcall .+216 ; 0xb2a
UIMgr_writeTxFifo('K');
a52: 8b e4 ldi r24, 0x4B ; 75
a54: 6a d0 rcall .+212 ; 0xb2a
UIMgr_writeTxFifo('\r');
a56: 8d e0 ldi r24, 0x0D ; 13
a58: 68 d0 rcall .+208 ; 0xb2a
}
a5a: 08 95 ret
00000a5c <UIMgr_sendNck>:
/***********************************************************
Function Name: UIMgr_sendNck
Function Description: This function is responsible for
queueing up an NCK to be sent to the user.
Inputs: none
Outputs: none
***********************************************************/
static void UIMgr_sendNck(void)
{
UIMgr_writeTxFifo('N');
a5c: 8e e4 ldi r24, 0x4E ; 78
a5e: 65 d0 rcall .+202 ; 0xb2a
UIMgr_writeTxFifo('C');
a60: 83 e4 ldi r24, 0x43 ; 67
a62: 63 d0 rcall .+198 ; 0xb2a
UIMgr_writeTxFifo('K');
a64: 8b e4 ldi r24, 0x4B ; 75
a66: 61 d0 rcall .+194 ; 0xb2a
UIMgr_writeTxFifo('\r');
a68: 8d e0 ldi r24, 0x0D ; 13
a6a: 5f d0 rcall .+190 ; 0xb2a
}
a6c: 08 95 ret
00000a6e <UIMgr_writeBufferToTxFifo>:
/***********************************************************
Function Name: UIMgr_writeBufferToTxFifo
Function Description: This function is responsible for
placing "length" bytes into the tx FIFO.
Inputs: pData - a pointer to the data to send
length - the number of bytes to send
Outputs: none
***********************************************************/
void UIMgr_writeBufferToTxFifo(unsigned char *pData, unsigned char length)
{
a6e: dc 01 movw r26, r24
unsigned char tmpHead;
if (length == 0)
a70: 66 23 and r22, r22
a72: a9 f0 breq .+42 ; 0xa9e
{
return;
}
DISABLE_INTS();
a74: f8 94 cli
while(length-- != 0)
a76: 61 50 subi r22, 0x01 ; 1
a78: 6f 3f cpi r22, 0xFF ; 255
a7a: 81 f0 breq .+32 ; 0xa9c
a7c: 24 e9 ldi r18, 0x94 ; 148
a7e: 32 e0 ldi r19, 0x02 ; 2
{
UIMgr_txFifo[UIMgr_txFifoHead] = *pData++;
a80: 90 91 ba 00 lds r25, 0x00BA
a84: f9 01 movw r30, r18
a86: e9 0f add r30, r25
a88: f1 1d adc r31, r1
a8a: 8d 91 ld r24, X+
a8c: 80 83 st Z, r24
/* now move the head up */
tmpHead = (UIMgr_txFifoHead + 1) & (UI_MGR_TX_FIFO_MASK);
a8e: 89 2f mov r24, r25
a90: 8f 5f subi r24, 0xFF ; 255
a92: 8f 73 andi r24, 0x3F ; 63
UIMgr_txFifoHead = tmpHead;
a94: 80 93 ba 00 sts 0x00BA, r24
a98: 61 50 subi r22, 0x01 ; 1
a9a: 90 f7 brcc .-28 ; 0xa80
}
ENABLE_INTS();
a9c: 78 94 sei
}
a9e: 08 95 ret
00000aa0 <UIMgr_txBuffer>:
/***********************************************************
Function Name: UIMgr_txBuffer
Function Description: This function is responsible for
sending 'length' bytes out using the UartInterface
module.
Inputs: pData - a pointer to the data to send
length - the number of bytes to send
Outputs: none
***********************************************************/
void UIMgr_txBuffer(unsigned char *pData, unsigned char length)
{
aa0: 0f 93 push r16
aa2: 1f 93 push r17
aa4: cf 93 push r28
aa6: 8c 01 movw r16, r24
aa8: c6 2f mov r28, r22
while(length-- != 0)
aaa: c1 50 subi r28, 0x01 ; 1
aac: cf 3f cpi r28, 0xFF ; 255
aae: 31 f0 breq .+12 ; 0xabc
{
UartInt_txByte(*pData++);
ab0: f8 01 movw r30, r16
ab2: 81 91 ld r24, Z+
ab4: 8f 01 movw r16, r30
ab6: 54 d0 rcall .+168 ; 0xb60
ab8: c1 50 subi r28, 0x01 ; 1
aba: d0 f7 brcc .-12 ; 0xab0
}
}
abc: cf 91 pop r28
abe: 1f 91 pop r17
ac0: 0f 91 pop r16
ac2: 08 95 ret
00000ac4 <UIMgr_flushTxBuffer>:
/***********************************************************
Function Name: UIMgr_flushTxBuffer
Function Description: This function is responsible for
sending all data currently in the serial tx buffer
to the user.
Inputs: none
Outputs: none
***********************************************************/
void UIMgr_flushTxBuffer(void)
{
while(IS_DATA_IN_TX_FIFO() == TRUE)
ac4: 90 91 ba 00 lds r25, 0x00BA
ac8: 80 91 bb 00 lds r24, 0x00BB
acc: 98 17 cp r25, r24
ace: 41 f0 breq .+16 ; 0xae0
{
UartInt_txByte(UIMgr_readTxFifo() );
ad0: 1a d0 rcall .+52 ; 0xb06
ad2: 46 d0 rcall .+140 ; 0xb60
ad4: 90 91 ba 00 lds r25, 0x00BA
ad8: 80 91 bb 00 lds r24, 0x00BB
adc: 98 17 cp r25, r24
ade: c1 f7 brne .-16 ; 0xad0
}
}
ae0: 08 95 ret
00000ae2 <UIMgr_readRxFifo>:
/***********************************************************
Function Name: UIMgr_readRxFifo
Function Description: This function is responsible for
reading a single byte of data from the rx fifo, and
updating the appropriate pointers.
Inputs: none
Outputs: unsigned char-the data read
***********************************************************/
static unsigned char UIMgr_readRxFifo(void)
{
unsigned char dataByte, tmpTail;
/* just return the current tail from the rx fifo */
DISABLE_INTS();
ae2: f8 94 cli
dataByte = UIMgr_rxFifo[UIMgr_rxFifoTail];
ae4: 20 91 b9 00 lds r18, 0x00B9
ae8: 84 e7 ldi r24, 0x74 ; 116
aea: 92 e0 ldi r25, 0x02 ; 2
aec: fc 01 movw r30, r24
aee: e2 0f add r30, r18
af0: f1 1d adc r31, r1
af2: 90 81 ld r25, Z
tmpTail = (UIMgr_rxFifoTail+1) & (UI_MGR_RX_FIFO_MASK);
af4: 82 2f mov r24, r18
af6: 8f 5f subi r24, 0xFF ; 255
af8: 8f 71 andi r24, 0x1F ; 31
UIMgr_rxFifoTail = tmpTail;
afa: 80 93 b9 00 sts 0x00B9, r24
ENABLE_INTS();
afe: 78 94 sei
return(dataByte);
b00: 89 2f mov r24, r25
b02: 99 27 eor r25, r25
}
b04: 08 95 ret
00000b06 <UIMgr_readTxFifo>:
/***********************************************************
Function Name: UIMgr_readTxFifo
Function Description: This function is responsible for
reading a single byte of data from the tx fifo, and
updating the appropriate pointers.
Inputs: none
Outputs: unsigned char-the data read
***********************************************************/
static unsigned char UIMgr_readTxFifo(void)
{
unsigned char dataByte, tmpTail;
/* just return the current tail from the tx fifo */
DISABLE_INTS();
b06: f8 94 cli
dataByte = UIMgr_txFifo[UIMgr_txFifoTail];
b08: 20 91 bb 00 lds r18, 0x00BB
b0c: 84 e9 ldi r24, 0x94 ; 148
b0e: 92 e0 ldi r25, 0x02 ; 2
b10: fc 01 movw r30, r24
b12: e2 0f add r30, r18
b14: f1 1d adc r31, r1
b16: 90 81 ld r25, Z
tmpTail = (UIMgr_txFifoTail+1) & (UI_MGR_TX_FIFO_MASK);
b18: 82 2f mov r24, r18
b1a: 8f 5f subi r24, 0xFF ; 255
b1c: 8f 73 andi r24, 0x3F ; 63
UIMgr_txFifoTail = tmpTail;
b1e: 80 93 bb 00 sts 0x00BB, r24
ENABLE_INTS();
b22: 78 94 sei
return(dataByte);
b24: 89 2f mov r24, r25
b26: 99 27 eor r25, r25
}
b28: 08 95 ret
00000b2a <UIMgr_writeTxFifo>:
/***********************************************************
Function Name: UIMgr_writeTxFifo
Function Description: This function is responsible for
writing a single byte to the TxFifo and
updating the appropriate pointers.
Inputs: data - the byte to write to the Fifo
Outputs: none
***********************************************************/
void UIMgr_writeTxFifo(unsigned char data)
{
b2a: 38 2f mov r19, r24
unsigned char tmpHead;
DISABLE_INTS();
b2c: f8 94 cli
UIMgr_txFifo[UIMgr_txFifoHead] = data;
b2e: 20 91 ba 00 lds r18, 0x00BA
b32: 84 e9 ldi r24, 0x94 ; 148
b34: 92 e0 ldi r25, 0x02 ; 2
b36: fc 01 movw r30, r24
b38: e2 0f add r30, r18
b3a: f1 1d adc r31, r1
b3c: 30 83 st Z, r19
/* now move the head up */
tmpHead = (UIMgr_txFifoHead + 1) & (UI_MGR_TX_FIFO_MASK);
b3e: 82 2f mov r24, r18
b40: 8f 5f subi r24, 0xFF ; 255
b42: 8f 73 andi r24, 0x3F ; 63
UIMgr_txFifoHead = tmpHead;
b44: 80 93 ba 00 sts 0x00BA, r24
ENABLE_INTS();
b48: 78 94 sei
}
b4a: 08 95 ret
00000b4c <UartInt_init>:
void UartInt_init(void)
{
/* set up the baud rate registers so the UART will operate
at 115.2 Kbps */
UBRRH = 0x00;
b4c: 10 bc out 0x20, r1 ; 32
#ifdef NO_CRYSTAL
UBRRL = 18; /* 18 for double clocking at 115.2 kbps */
b4e: 82 e1 ldi r24, 0x12 ; 18
b50: 89 b9 out 0x09, r24 ; 9
#else
UBRRL = 0x08; /* for 16 MHz crystal at 115.2 kbps */
#endif
/* enable the tx and rx capabilities of the UART...as well
as the receive complete interrupt */
UCSRB = (1<<RXCIE)|(1<<RXEN)|(1<<TXEN);
b52: 88 e9 ldi r24, 0x98 ; 152
b54: 8a b9 out 0x0a, r24 ; 10
/* set up the control registers so the UART works at 8N1 */
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);
b56: 86 e8 ldi r24, 0x86 ; 134
b58: 80 bd out 0x20, r24 ; 32
#ifdef NO_CRYSTAL
/* set the baud rate to use the double-speed */
UCSRA = (1<<U2X);
b5a: 82 e0 ldi r24, 0x02 ; 2
b5c: 8b b9 out 0x0b, r24 ; 11
#endif
}
b5e: 08 95 ret
00000b60 <UartInt_txByte>:
/***********************************************************
Function Name: UartInt_txByte
Function Description: This function is responsible for
transmitting a single byte on the uart.
Inputs: txByte - the byte to send
Outputs: none
NOTES: When the TX UDRE (data register empty) is set, there
is puposefully no interrupt...thus, to send a string of
data out, the calling routine needs to hold up the entire
application while this takes place (or just send one
byte at a time at strtegically timed intervals, like
the stats data is sent out :-)
***********************************************************/
void UartInt_txByte(unsigned char txByte)
{
/* Wait for empty transmit buffer */
while ( !( UCSRA & (1<<UDRE)) );
b60: 5d 9b sbis 0x0b, 5 ; 11
b62: fe cf rjmp .-4 ; 0xb60
/* Put data into buffer, sends the data */
UDR = txByte;
b64: 8c b9 out 0x0c, r24 ; 12
}
b66: 08 95 ret
00000b68 <__vector_11>:
/***********************************************************
Function Name: SIG_UART_RECV ISR
Function Description: This function is responsible for
handling the interrupt caused when a data byte is
received by the UART.
Inputs: none
Outputs: none
NOTES: This function was originally written in assembly,
but moved over to C when the setting of the "T" bit at
the end of the routine was no longer necessary (this
theoretically allowed the AVRcam to respond to serial
bytes in the middle of tracking or dumping a frame.
But it wasn't really needed, and understanding the C
is easier :-)
***********************************************************/
SIGNAL(SIG_UART_RECV)
{
b68: 1f 92 push r1
b6a: 0f 92 push r0
b6c: 0f b6 in r0, 0x3f ; 63
b6e: 0f 92 push r0
b70: 11 24 eor r1, r1
b72: 2f 93 push r18
b74: 8f 93 push r24
b76: 9f 93 push r25
b78: ef 93 push r30
b7a: ff 93 push r31
unsigned char tmpHead;
/* read the data byte, put it in the serial queue, and
post the event */
UIMgr_rxFifo[UIMgr_rxFifoHead] = UDR;
b7c: 20 91 b8 00 lds r18, 0x00B8
b80: 84 e7 ldi r24, 0x74 ; 116
b82: 92 e0 ldi r25, 0x02 ; 2
b84: fc 01 movw r30, r24
b86: e2 0f add r30, r18
b88: f1 1d adc r31, r1
b8a: 8c b1 in r24, 0x0c ; 12
b8c: 80 83 st Z, r24
/* now move the head up */
tmpHead = (UIMgr_rxFifoHead + 1) & (UI_MGR_RX_FIFO_MASK);
b8e: 2f 5f subi r18, 0xFF ; 255
b90: 2f 71 andi r18, 0x1F ; 31
UIMgr_rxFifoHead = tmpHead;
b92: 20 93 b8 00 sts 0x00B8, r18
/* write the serial received event to the event fifo */
Exec_eventFifo[Exec_eventFifoHead] = EV_SERIAL_DATA_RECEIVED;
b96: 20 91 70 00 lds r18, 0x0070
b9a: 8c e6 ldi r24, 0x6C ; 108
b9c: 92 e0 ldi r25, 0x02 ; 2
b9e: fc 01 movw r30, r24
ba0: e2 0f add r30, r18
ba2: f1 1d adc r31, r1
ba4: 81 e0 ldi r24, 0x01 ; 1
ba6: 80 83 st Z, r24
/* now move the head up */
tmpHead = (Exec_eventFifoHead + 1) & (EXEC_EVENT_FIFO_MASK);
ba8: 28 0f add r18, r24
baa: 27 70 andi r18, 0x07 ; 7
Exec_eventFifoHead = tmpHead;
bac: 20 93 70 00 sts 0x0070, r18
}
bb0: ff 91 pop r31
bb2: ef 91 pop r30
bb4: 9f 91 pop r25
bb6: 8f 91 pop r24
bb8: 2f 91 pop r18
bba: 0f 90 pop r0
bbc: 0f be out 0x3f, r0 ; 63
bbe: 0f 90 pop r0
bc0: 1f 90 pop r1
bc2: 18 95 reti
00000bc4 <I2CInt_init>:
Outputs: none
***********************************************************/
void I2CInt_init(void)
{
TWSR = 0;
bc4: 11 b8 out 0x01, r1 ; 1
/* init the speed of the I2C interface, running at
100 Kbps */
TWBR = (FOSC / I2C_SPEED - 16)/2;
bc6: 88 e4 ldi r24, 0x48 ; 72
bc8: 80 b9 out 0x00, r24 ; 0
}
bca: 08 95 ret
00000bcc <I2CInt_writeData>:
/***********************************************************
Function Name: I2CInt_writeData
Function Description: This function is responsible for
initiating the process of writing a sequence of bytes
an I2C slave address. This function will try to write
the data three times before giving up.
Inputs: address: the address of the I2C slave device
data: a pointer to the data to be written
to the slave...for camera interfacing,
the data follows a <register #><data>
format
bytes: the number of bytes to write
Outputs: none
***********************************************************/
void I2CInt_writeData(unsigned char address, unsigned char *data, unsigned char bytes)
{
bcc: 98 2f mov r25, r24
while(status & (1<<BUSY)); /* Bus is busy wait (or exit with error code) */
bce: 80 91 08 01 lds r24, 0x0108
bd2: 88 23 and r24, r24
bd4: e4 f3 brlt .-8 ; 0xbce
while(TWCR & (1<<TWSTO));
bd6: 06 b6 in r0, 0x36 ; 54
bd8: 04 fc sbrc r0, 4
bda: fd cf rjmp .-6 ; 0xbd6
/* copy the needed data and state info to our local I2C command structure */
twi_address = address;
bdc: 90 93 03 01 sts 0x0103, r25
twi_data = data;
be0: 70 93 05 01 sts 0x0105, r23
be4: 60 93 04 01 sts 0x0104, r22
twi_bytes = bytes;
be8: 40 93 07 01 sts 0x0107, r20
twi_ddr = TW_WRITE;
bec: 10 92 06 01 sts 0x0106, r1
retry_cnt = 0;
bf0: 10 92 09 01 sts 0x0109, r1
/* Generate start condition, the remainder of the transfer is interrupt driven and
will be performed in the background */
TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN)|(1<<TWIE);
bf4: 85 ea ldi r24, 0xA5 ; 165
bf6: 86 bf out 0x36, r24 ; 54
status |= (1<<BUSY);
bf8: 80 91 08 01 lds r24, 0x0108
bfc: 80 68 ori r24, 0x80 ; 128
bfe: 80 93 08 01 sts 0x0108, r24
}
c02: 08 95 ret
00000c04 <I2CInt_readData>:
/***********************************************************
Function Name: I2CInt_readData
Function Description: This funcion is responsible for
reading the specified number of bytes from a slave
device.
Inputs: address: the slave address to read from
data: a pointer to where the data will be stored
bytes: the number of bytes to read
Outputs: none
***********************************************************/
void I2CInt_readData(unsigned char address, unsigned char *data, unsigned char bytes)
{
c04: 98 2f mov r25, r24
/* Bus is busy wait (or exit with error code) */
while(status & (1<<BUSY));
c06: 80 91 08 01 lds r24, 0x0108
c0a: 88 23 and r24, r24
c0c: e4 f3 brlt .-8 ; 0xc06
twi_address = address;
c0e: 90 93 03 01 sts 0x0103, r25
twi_data = data;
c12: 70 93 05 01 sts 0x0105, r23
c16: 60 93 04 01 sts 0x0104, r22
twi_bytes = bytes;
c1a: 40 93 07 01 sts 0x0107, r20
twi_ddr = TW_READ;
c1e: 81 e0 ldi r24, 0x01 ; 1
c20: 80 93 06 01 sts 0x0106, r24
retry_cnt = 0;
c24: 10 92 09 01 sts 0x0109, r1
/* Generate start condition, the remainder of the transfer is interrupt driven and
will be performed in the background */
TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN)|(1<<TWIE);
c28: 85 ea ldi r24, 0xA5 ; 165
c2a: 86 bf out 0x36, r24 ; 54
status |= (1<<BUSY);
c2c: 80 91 08 01 lds r24, 0x0108
c30: 80 68 ori r24, 0x80 ; 128
c32: 80 93 08 01 sts 0x0108, r24
}
c36: 08 95 ret
00000c38 <I2CInt_isI2cBusy>:
/***********************************************************
Function Name: I2CInt_isI2cBusy
Function Description: This funcion is responsible for
indicating if the I2C bus is currently busy to external
modules.
device.
Inputs: none
Outputs: bool_t - indicating if bus is busy
***********************************************************/
bool_t I2CInt_isI2cBusy(void)
{
bool_t retVal = FALSE;
c38: 90 e0 ldi r25, 0x00 ; 0
if ( (status & (1<<BUSY)) != 0)
c3a: 80 91 08 01 lds r24, 0x0108
c3e: 88 23 and r24, r24
c40: 0c f4 brge .+2 ; 0xc44
{
retVal = TRUE;
c42: 91 e0 ldi r25, 0x01 ; 1
}
return(retVal);
c44: 89 2f mov r24, r25
c46: 99 27 eor r25, r25
}
c48: 08 95 ret
00000c4a <__vector_17>:
/***********************************************************
Function Name: <interrupt handler for I2C>
Function Description: This function is responsible for
implementing the control logic needed to perform a
read or write operation with an I2C slave.
Inputs: none
Outputs: none
***********************************************************/
SIGNAL(SIG_2WIRE_SERIAL)
{
c4a: 1f 92 push r1
c4c: 0f 92 push r0
c4e: 0f b6 in r0, 0x3f ; 63
c50: 0f 92 push r0
c52: 11 24 eor r1, r1
c54: 8f 93 push r24
c56: 9f 93 push r25
c58: af 93 push r26
c5a: bf 93 push r27
c5c: ef 93 push r30
c5e: ff 93 push r31
unsigned char TWI_status = TWSR & TW_STATUS_MASK; /* grab just the status bits */
c60: 81 b1 in r24, 0x01 ; 1
c62: 88 7f andi r24, 0xF8 ; 248
/* the entire I2C handler is state-based...determine
what needs to be done based on TWI_status */
switch(TWI_status)
c64: 99 27 eor r25, r25
c66: aa 27 eor r26, r26
c68: bb 27 eor r27, r27
c6a: fc 01 movw r30, r24
c6c: 38 97 sbiw r30, 0x08 ; 8
c6e: e1 35 cpi r30, 0x51 ; 81
c70: f1 05 cpc r31, r1
c72: 08 f0 brcs .+2 ; 0xc76
c74: 6d c0 rjmp .+218 ; 0xd50
c76: ed 5e subi r30, 0xED ; 237
c78: ff 4f sbci r31, 0xFF ; 255
c7a: 09 94 ijmp
{
case TW_START: /* Start condition */
case TW_REP_START: /* Repeated start condition */
if(retry_cnt > MAX_TWI_RETRIES)
c7c: 80 91 09 01 lds r24, 0x0109
c80: 83 30 cpi r24, 0x03 ; 3
c82: 08 f0 brcs .+2 ; 0xc86
c84: 5d c0 rjmp .+186 ; 0xd40
{
/* generate stop condition if we've reached our retry limit */
TWCR |= (1<<TWINT)|(1<<TWSTO);
status &= ~(1<<BUSY);
return;
}
/* indicate read or write */
TWDR = (twi_address<<1) + twi_ddr;
c86: 80 91 03 01 lds r24, 0x0103
c8a: 98 2f mov r25, r24
c8c: 99 0f add r25, r25
c8e: 80 91 06 01 lds r24, 0x0106
c92: 89 0f add r24, r25
c94: 83 b9 out 0x03, r24 ; 3
/* TWSTA must be cleared...also clears TWINT */
TWCR &= ~(1<<TWSTA);
c96: 86 b7 in r24, 0x36 ; 54
c98: 8f 7d andi r24, 0xDF ; 223
c9a: 4a c0 rjmp .+148 ; 0xd30
break;
case TW_MT_SLA_ACK: /* Slave acknowledged address, */
retry_cnt = 0;
c9c: 10 92 09 01 sts 0x0109, r1
/* tx the data, and increment the data pointer */
TWDR = *twi_data;
ca0: 11 c0 rjmp .+34 ; 0xcc4
twi_data++;
/* clear the int to continue */
TWCR |= (1<<TWINT);
break;
case TW_MT_SLA_NACK: /* Slave didn't acknowledge address, */
case TW_MR_SLA_NACK:
retry_cnt++;
ca2: 80 91 09 01 lds r24, 0x0109
ca6: 8f 5f subi r24, 0xFF ; 255
ca8: 80 93 09 01 sts 0x0109, r24
/* retry...*/
TWCR |= (1<<TWINT)|(1<<TWSTA)|(1<<TWSTO);
cac: 86 b7 in r24, 0x36 ; 54
cae: 80 6b ori r24, 0xB0 ; 176
cb0: 3f c0 rjmp .+126 ; 0xd30
break;
case TW_MT_DATA_ACK: /* Slave Acknowledged data, */
if(--twi_bytes > 0)
cb2: 80 91 07 01 lds r24, 0x0107
cb6: 81 50 subi r24, 0x01 ; 1
cb8: 80 93 07 01 sts 0x0107, r24
cbc: 80 91 07 01 lds r24, 0x0107
cc0: 88 23 and r24, r24
cc2: f1 f1 breq .+124 ; 0xd40
{
/* more data to send, so send it */
TWDR = *twi_data;
cc4: e0 91 04 01 lds r30, 0x0104
cc8: f0 91 05 01 lds r31, 0x0105
ccc: 80 81 ld r24, Z
cce: 83 b9 out 0x03, r24 ; 3
twi_data++;
cd0: cf 01 movw r24, r30
cd2: 01 96 adiw r24, 0x01 ; 1
cd4: 90 93 05 01 sts 0x0105, r25
cd8: 80 93 04 01 sts 0x0104, r24
TWCR |= (1<<TWINT);
cdc: 09 c0 rjmp .+18 ; 0xcf0
}
else
{
/* generate the stop condition if needed */
TWCR |= (1<<TWSTO)|(1<<TWINT);
status &= ~(1<<BUSY);
}
break;
case TW_MT_DATA_NACK: /* Slave didn't acknowledge data */
/* send the stop condition */
TWCR |= (1<<TWINT)|(1<<TWSTO);
status &= ~(1<<BUSY);
break;
case TW_MR_SLA_ACK: /* Slave acknowledged address */
if(--twi_bytes > 0)
cde: 80 91 07 01 lds r24, 0x0107
ce2: 81 50 subi r24, 0x01 ; 1
ce4: 80 93 07 01 sts 0x0107, r24
ce8: 80 91 07 01 lds r24, 0x0107
cec: 88 23 and r24, r24
cee: d9 f4 brne .+54 ; 0xd26
{
/* if there is more than one byte to read, acknowledge */
TWCR |= (1<<TWEA)|(1<<TWINT);
}
else
{
/* no acknowledge */
TWCR |= (1<<TWINT);
cf0: 86 b7 in r24, 0x36 ; 54
cf2: 80 68 ori r24, 0x80 ; 128
cf4: 1d c0 rjmp .+58 ; 0xd30
}
break;
case TW_MR_DATA_ACK: /* Master acknowledged data */
/* grab the received data */
*twi_data = TWDR;
cf6: e0 91 04 01 lds r30, 0x0104
cfa: f0 91 05 01 lds r31, 0x0105
cfe: 83 b1 in r24, 0x03 ; 3
d00: 80 83 st Z, r24
twi_data++;
d02: 80 91 04 01 lds r24, 0x0104
d06: 90 91 05 01 lds r25, 0x0105
d0a: 01 96 adiw r24, 0x01 ; 1
d0c: 90 93 05 01 sts 0x0105, r25
d10: 80 93 04 01 sts 0x0104, r24
if(--twi_bytes > 0)
d14: 80 91 07 01 lds r24, 0x0107
d18: 81 50 subi r24, 0x01 ; 1
d1a: 80 93 07 01 sts 0x0107, r24
d1e: 80 91 07 01 lds r24, 0x0107
d22: 88 23 and r24, r24
d24: 19 f0 breq .+6 ; 0xd2c
{
/* get the next data byte and ack */
TWCR |= (1<<TWEA)|(1<<TWINT);
d26: 86 b7 in r24, 0x36 ; 54
d28: 80 6c ori r24, 0xC0 ; 192
d2a: 02 c0 rjmp .+4 ; 0xd30
}
else
{
/* clear out the enable acknowledge bit */
TWCR &= ~(1<<TWEA);
d2c: 86 b7 in r24, 0x36 ; 54
d2e: 8f 7b andi r24, 0xBF ; 191
d30: 86 bf out 0x36, r24 ; 54
}
break;
d32: 0e c0 rjmp .+28 ; 0xd50
case TW_MR_DATA_NACK: /* Master didn't acknowledge data -> end of read process */
/* read data, and generate the stop condition */
*twi_data = TWDR;
d34: e0 91 04 01 lds r30, 0x0104
d38: f0 91 05 01 lds r31, 0x0105
d3c: 83 b1 in r24, 0x03 ; 3
d3e: 80 83 st Z, r24
TWCR |= (1<<TWSTO)|(1<<TWINT);
d40: 86 b7 in r24, 0x36 ; 54
d42: 80 69 ori r24, 0x90 ; 144
d44: 86 bf out 0x36, r24 ; 54
status &= ~(1<<BUSY);
d46: 80 91 08 01 lds r24, 0x0108
d4a: 8f 77 andi r24, 0x7F ; 127
d4c: 80 93 08 01 sts 0x0108, r24
break;
}
}
d50: ff 91 pop r31
d52: ef 91 pop r30
d54: bf 91 pop r27
d56: af 91 pop r26
d58: 9f 91 pop r25
d5a: 8f 91 pop r24
d5c: 0f 90 pop r0
d5e: 0f be out 0x3f, r0 ; 63
d60: 0f 90 pop r0
d62: 1f 90 pop r1
d64: 18 95 reti
00000d66 <CamConfig_init>:
Outputs: none
***********************************************************/
void CamConfig_init(void)
{
CamConfig_setCamReg(0x14,0x20); /* reduce frame size */
d66: 60 e2 ldi r22, 0x20 ; 32
d68: 84 e1 ldi r24, 0x14 ; 20
d6a: 0e d0 rcall .+28 ; 0xd88
CamConfig_setCamReg(0x39,0x40); /* gate PCLK with HREF */
d6c: 60 e4 ldi r22, 0x40 ; 64
d6e: 89 e3 ldi r24, 0x39 ; 57
d70: 0b d0 rcall .+22 ; 0xd88
CamConfig_setCamReg(0x12,0x28); /* set RGB mode, with no AWB */
d72: 68 e2 ldi r22, 0x28 ; 40
d74: 82 e1 ldi r24, 0x12 ; 18
d76: 08 d0 rcall .+16 ; 0xd88
CamConfig_setCamReg(0x28,0x05); /* set color sequencer */
d78: 65 e0 ldi r22, 0x05 ; 5
d7a: 88 e2 ldi r24, 0x28 ; 40
d7c: 05 d0 rcall .+10 ; 0xd88
CamConfig_setCamReg(0x13,0x01); /* un-tri-state the Y/UV lines */
d7e: 61 e0 ldi r22, 0x01 ; 1
d80: 83 e1 ldi r24, 0x13 ; 19
d82: 02 d0 rcall .+4 ; 0xd88
/* send the first four cmds in the I2C fifo */
CamConfig_sendFifoCmds();
d84: 06 d0 rcall .+12 ; 0xd92
}
d86: 08 95 ret
00000d88 <CamConfig_setCamReg>:
/***********************************************************
Function Name: CamConfig_setCamReg
Function Description: This function is responsible for
creating an I2C cmd structure and placing it into the
cmd fifo.
Inputs: reg - the register to modify
val - the new value of the register
Outputs: none
***********************************************************/
void CamConfig_setCamReg(unsigned char reg, unsigned char val)
{
i2cCmd_t cmd;
cmd.configReg = reg;
d88: 28 2f mov r18, r24
cmd.data = val;
d8a: 36 2f mov r19, r22
#ifndef SIMULATION
CamConfig_writeTxFifo(cmd);
d8c: c9 01 movw r24, r18
d8e: 2f d0 rcall .+94 ; 0xdee
#endif
}
d90: 08 95 ret
00000d92 <CamConfig_sendFifoCmds>:
/***********************************************************
Function Name: CamConfig_sendFifoCmds
Function Description: This function is responsible for
sending the entire contents of the config fifo. This
function won't return until the configuration process
is complete (or an error is encountered).
Inputs: none
Outputs: none
Note: Since this function is written to use the TWI
interrupt in the I2CInterface module, there will be
some busy-waiting here...no big deal, since we end up
having to trash the frame that we are executing this
slave write in anyway (since we can't meet the strict
timing requirements and write i2c at the same time).
***********************************************************/
void CamConfig_sendFifoCmds(void)
{
d92: cf 93 push r28
d94: df 93 push r29
d96: cd b7 in r28, 0x3d ; 61
d98: de b7 in r29, 0x3e ; 62
d9a: 22 97 sbiw r28, 0x02 ; 2
d9c: 0f b6 in r0, 0x3f ; 63
d9e: f8 94 cli
da0: de bf out 0x3e, r29 ; 62
da2: 0f be out 0x3f, r0 ; 63
da4: cd bf out 0x3d, r28 ; 61
i2cCmd_t cmd;
while (CamConfig_txFifoHead != CamConfig_txFifoTail)
da6: 90 91 0a 01 lds r25, 0x010A
daa: 80 91 0b 01 lds r24, 0x010B
dae: 98 17 cp r25, r24
db0: a9 f0 breq .+42 ; 0xddc
{
cmd = CamConfig_readTxFifo();
db2: 37 d0 rcall .+110 ; 0xe22
db4: 89 83 std Y+1, r24 ; 0x01
db6: 9a 83 std Y+2, r25 ; 0x02
I2CInt_writeData(CAM_ADDRESS,&cmd.configReg,SIZE_OF_I2C_CMD);
db8: 42 e0 ldi r20, 0x02 ; 2
dba: be 01 movw r22, r28
dbc: 6f 5f subi r22, 0xFF ; 255
dbe: 7f 4f sbci r23, 0xFF ; 255
dc0: 80 e6 ldi r24, 0x60 ; 96
dc2: 04 df rcall .-504 ; 0xbcc
Utility_delay(100);
dc4: 84 e6 ldi r24, 0x64 ; 100
dc6: 90 e0 ldi r25, 0x00 ; 0
dc8: 3e d0 rcall .+124 ; 0xe46
/* wait for the I2C transaction to complete */
while(I2CInt_isI2cBusy() == TRUE);
dca: 36 df rcall .-404 ; 0xc38
dcc: 81 30 cpi r24, 0x01 ; 1
dce: e9 f3 breq .-6 ; 0xdca
dd0: 90 91 0a 01 lds r25, 0x010A
dd4: 80 91 0b 01 lds r24, 0x010B
dd8: 98 17 cp r25, r24
dda: 59 f7 brne .-42 ; 0xdb2
}
}
ddc: 22 96 adiw r28, 0x02 ; 2
dde: 0f b6 in r0, 0x3f ; 63
de0: f8 94 cli
de2: de bf out 0x3e, r29 ; 62
de4: 0f be out 0x3f, r0 ; 63
de6: cd bf out 0x3d, r28 ; 61
de8: df 91 pop r29
dea: cf 91 pop r28
dec: 08 95 ret
00000dee <CamConfig_writeTxFifo>:
/***********************************************************
Function Name: CamConfig_writeTxFifo
Function Description: This function is responsible for
adding a new command to the tx fifo. It adjusts all
needed pointers.
Inputs: cmd - the i2cCmd_t to add to the fifo
Outputs: bool_t - indicating if writing to the fifo
causes it to wrap
***********************************************************/
bool_t CamConfig_writeTxFifo(i2cCmd_t cmd)
{
dee: 9c 01 movw r18, r24
unsigned char tmpHead;
bool_t retVal = TRUE;
df0: 51 e0 ldi r21, 0x01 ; 1
CamConfig_txFifo[CamConfig_txFifoHead] = cmd;
df2: 40 91 0a 01 lds r20, 0x010A
df6: 84 2f mov r24, r20
df8: 99 27 eor r25, r25
dfa: 88 0f add r24, r24
dfc: 99 1f adc r25, r25
dfe: fc 01 movw r30, r24
e00: ec 52 subi r30, 0x2C ; 44
e02: fd 4f sbci r31, 0xFD ; 253
e04: 20 83 st Z, r18
e06: 31 83 std Z+1, r19 ; 0x01
/* see if we need to wrap */
tmpHead = (CamConfig_txFifoHead+1) & (CAM_CONFIG_TX_FIFO_MASK);
e08: 84 2f mov r24, r20
e0a: 85 0f add r24, r21
e0c: 87 70 andi r24, 0x07 ; 7
CamConfig_txFifoHead = tmpHead;
e0e: 80 93 0a 01 sts 0x010A, r24
/* check to see if we have filled up the queue */
if (CamConfig_txFifoHead == CamConfig_txFifoTail)
e12: 90 91 0b 01 lds r25, 0x010B
e16: 89 17 cp r24, r25
e18: 09 f4 brne .+2 ; 0xe1c
{
/* we wrapped the fifo...return false */
retVal = FALSE;
e1a: 50 e0 ldi r21, 0x00 ; 0
}
return(retVal);
e1c: 85 2f mov r24, r21
e1e: 99 27 eor r25, r25
}
e20: 08 95 ret
00000e22 <CamConfig_readTxFifo>:
/***********************************************************
Function Name: CamConfig_readTxFifo
Function Description: This function is responsible for
reading a cmd out of the tx fifo.
Inputs: none
Outputs: i2cCmd_t - the cmd read from the fifo
***********************************************************/
static i2cCmd_t CamConfig_readTxFifo(void)
{
i2cCmd_t cmd;
unsigned char tmpTail;
/* just return the current tail from the rx fifo */
cmd = CamConfig_txFifo[CamConfig_txFifoTail];
e22: 40 91 0b 01 lds r20, 0x010B
e26: 84 2f mov r24, r20
e28: 99 27 eor r25, r25
e2a: 88 0f add r24, r24
e2c: 99 1f adc r25, r25
e2e: fc 01 movw r30, r24
e30: ec 52 subi r30, 0x2C ; 44
e32: fd 4f sbci r31, 0xFD ; 253
e34: 20 81 ld r18, Z
e36: 31 81 ldd r19, Z+1 ; 0x01
tmpTail = (CamConfig_txFifoTail+1) & (CAM_CONFIG_TX_FIFO_MASK);
e38: 84 2f mov r24, r20
e3a: 8f 5f subi r24, 0xFF ; 255
e3c: 87 70 andi r24, 0x07 ; 7
CamConfig_txFifoTail = tmpTail;
e3e: 80 93 0b 01 sts 0x010B, r24
return(cmd);
}
e42: c9 01 movw r24, r18
e44: 08 95 ret
00000e46 <Utility_delay>:
if needed...this isn't really a millisecond, so DON'T
depend on it for exact timing...
***********************************************************/
void Utility_delay(unsigned short numMs)
{
e46: cf 93 push r28
e48: df 93 push r29
e4a: cd b7 in r28, 0x3d ; 61
e4c: de b7 in r29, 0x3e ; 62
e4e: 24 97 sbiw r28, 0x04 ; 4
e50: 0f b6 in r0, 0x3f ; 63
e52: f8 94 cli
e54: de bf out 0x3e, r29 ; 62
e56: 0f be out 0x3f, r0 ; 63
e58: cd bf out 0x3d, r28 ; 61
e5a: 9c 01 movw r18, r24
volatile unsigned short i=0,j=0;
e5c: 19 82 std Y+1, r1 ; 0x01
e5e: 1a 82 std Y+2, r1 ; 0x02
e60: 1b 82 std Y+3, r1 ; 0x03
e62: 1c 82 std Y+4, r1 ; 0x04
#ifndef SIMULATION
for (i=0; i<numMs; i++)
e64: 19 82 std Y+1, r1 ; 0x01
e66: 1a 82 std Y+2, r1 ; 0x02
e68: 89 81 ldd r24, Y+1 ; 0x01
e6a: 9a 81 ldd r25, Y+2 ; 0x02
e6c: 82 17 cp r24, r18
e6e: 93 07 cpc r25, r19
e70: e0 f4 brcc .+56 ; 0xeaa
{
for (j=0; j<1000; j++)
e72: 1b 82 std Y+3, r1 ; 0x03
e74: 1c 82 std Y+4, r1 ; 0x04
e76: 8b 81 ldd r24, Y+3 ; 0x03
e78: 9c 81 ldd r25, Y+4 ; 0x04
e7a: 88 5e subi r24, 0xE8 ; 232
e7c: 93 40 sbci r25, 0x03 ; 3
e7e: 58 f4 brcc .+22 ; 0xe96
{
asm volatile("nop"::);
e80: 00 00 nop
e82: 8b 81 ldd r24, Y+3 ; 0x03
e84: 9c 81 ldd r25, Y+4 ; 0x04
e86: 01 96 adiw r24, 0x01 ; 1
e88: 8b 83 std Y+3, r24 ; 0x03
e8a: 9c 83 std Y+4, r25 ; 0x04
e8c: 8b 81 ldd r24, Y+3 ; 0x03
e8e: 9c 81 ldd r25, Y+4 ; 0x04
e90: 88 5e subi r24, 0xE8 ; 232
e92: 93 40 sbci r25, 0x03 ; 3
e94: a8 f3 brcs .-22 ; 0xe80
e96: 89 81 ldd r24, Y+1 ; 0x01
e98: 9a 81 ldd r25, Y+2 ; 0x02
e9a: 01 96 adiw r24, 0x01 ; 1
e9c: 89 83 std Y+1, r24 ; 0x01
e9e: 9a 83 std Y+2, r25 ; 0x02
ea0: 89 81 ldd r24, Y+1 ; 0x01
ea2: 9a 81 ldd r25, Y+2 ; 0x02
ea4: 82 17 cp r24, r18
ea6: 93 07 cpc r25, r19
ea8: 20 f3 brcs .-56 ; 0xe72
}
}
#endif
}
eaa: 24 96 adiw r28, 0x04 ; 4
eac: 0f b6 in r0, 0x3f ; 63
eae: f8 94 cli
eb0: de bf out 0x3e, r29 ; 62
eb2: 0f be out 0x3f, r0 ; 63
eb4: cd bf out 0x3d, r28 ; 61
eb6: df 91 pop r29
eb8: cf 91 pop r28
eba: 08 95 ret
00000ebc <DebugInt_init>:
Inputs: none
Outputs: none
***********************************************************/
void DebugInt_init(void)
{
ebc: 1f 93 push r17
/* set PortD pin6 for output */
DDRD |= 0x40;
ebe: 8e 9a sbi 0x11, 6 ; 17
/* turn on LED */
PORTD |= 0x40;
ec0: 96 9a sbi 0x12, 6 ; 18
Utility_delay(500);
ec2: 84 ef ldi r24, 0xF4 ; 244
ec4: 91 e0 ldi r25, 0x01 ; 1
ec6: bf df rcall .-130 ; 0xe46
PORTD &= 0xBF;
ec8: 1f eb ldi r17, 0xBF ; 191
eca: 82 b3 in r24, 0x12 ; 18
ecc: 81 23 and r24, r17
ece: 82 bb out 0x12, r24 ; 18
Utility_delay(500);
ed0: 84 ef ldi r24, 0xF4 ; 244
ed2: 91 e0 ldi r25, 0x01 ; 1
ed4: b8 df rcall .-144 ; 0xe46
PORTD |= 0x40;
ed6: 96 9a sbi 0x12, 6 ; 18
Utility_delay(500);
ed8: 84 ef ldi r24, 0xF4 ; 244
eda: 91 e0 ldi r25, 0x01 ; 1
edc: b4 df rcall .-152 ; 0xe46
PORTD &= 0xBF;
ede: 82 b3 in r24, 0x12 ; 18
ee0: 81 23 and r24, r17
ee2: 82 bb out 0x12, r24 ; 18
Utility_delay(500);
ee4: 84 ef ldi r24, 0xF4 ; 244
ee6: 91 e0 ldi r25, 0x01 ; 1
ee8: ae df rcall .-164 ; 0xe46
PORTD |= 0x40;
eea: 96 9a sbi 0x12, 6 ; 18
Utility_delay(500);
eec: 84 ef ldi r24, 0xF4 ; 244
eee: 91 e0 ldi r25, 0x01 ; 1
ef0: aa df rcall .-172 ; 0xe46
PORTD &= 0xBF;
ef2: 82 b3 in r24, 0x12 ; 18
ef4: 81 23 and r24, r17
ef6: 82 bb out 0x12, r24 ; 18
Utility_delay(500);
ef8: 84 ef ldi r24, 0xF4 ; 244
efa: 91 e0 ldi r25, 0x01 ; 1
efc: a4 df rcall .-184 ; 0xe46
PORTD |= 0x40;
efe: 96 9a sbi 0x12, 6 ; 18
}
f00: 1f 91 pop r17
f02: 08 95 ret
00000f04 <CamIntAsm_waitForNewTrackingFrame>:
a5c: 98 81 ld r25, Y
a5e: 98 17 cp r25, r24
a60: 79 f0 breq .+30 ; 0xa80 <UIMgr_processReceivedData+0x178>
void
eeprom_write_byte (uint8_t *addr,uint8_t value)
{
asm volatile (
a62: d9 01 movw r26, r18
a64: 09 2e mov r0, r25
a66: 1e d3 rcall .+1596 ; 0x10a4 <__eeprom_write_byte_1C1D1E>
a68: d9 01 movw r26, r18
a6a: 0f d3 rcall .+1566 ; 0x108a <__eeprom_read_byte_1C1D1E>
a6c: 80 2d mov r24, r0
a6e: 98 81 ld r25, Y
a70: 98 17 cp r25, r24
a72: 31 f0 breq .+12 ; 0xa80 <UIMgr_processReceivedData+0x178>
void
eeprom_write_byte (uint8_t *addr,uint8_t value)
{
asm volatile (
a74: d9 01 movw r26, r18
a76: 09 2e mov r0, r25
a78: 15 d3 rcall .+1578 ; 0x10a4 <__eeprom_write_byte_1C1D1E>
a7a: d9 01 movw r26, r18
a7c: 06 d3 rcall .+1548 ; 0x108a <__eeprom_read_byte_1C1D1E>
a7e: 80 2d mov r24, r0
a80: 4f 5f subi r20, 0xFF ; 255
a82: 80 91 bc 00 lds r24, 0x00BC
a86: 48 17 cp r20, r24
a88: 88 f2 brcs .-94 ; 0xa2c <UIMgr_processReceivedData+0x124>
a8a: 10 92 bc 00 sts 0x00BC, r1
a8e: 80 e4 ldi r24, 0x40 ; 64
a90: e3 ec ldi r30, 0xC3 ; 195
a92: f0 e0 ldi r31, 0x00 ; 0
a94: 11 92 st Z+, r1
a96: 8a 95 dec r24
a98: e9 f7 brne .-6 ; 0xa94 <UIMgr_processReceivedData+0x18c>
a9a: 3f c0 rjmp .+126 ; 0xb1a <UIMgr_processReceivedData+0x212>
a9c: 90 32 cpi r25, 0x20 ; 32
a9e: f1 f4 brne .+60 ; 0xadc <UIMgr_processReceivedData+0x1d4>
aa0: 80 91 bc 00 lds r24, 0x00BC
aa4: 88 23 and r24, r24
aa6: 39 f4 brne .+14 ; 0xab6 <UIMgr_processReceivedData+0x1ae>
aa8: 8f de rcall .-738 ; 0x7c8 <UIMgr_convertTokenToCmd>
aaa: 80 91 bc 00 lds r24, 0x00BC
aae: 8f 5f subi r24, 0xFF ; 255
ab0: 80 93 bc 00 sts 0x00BC, r24
ab4: 32 c0 rjmp .+100 ; 0xb1a <UIMgr_processReceivedData+0x212>
ab6: 99 27 eor r25, r25
ab8: cf 97 sbiw r24, 0x3f ; 63
aba: 4c f0 brlt .+18 ; 0xace <UIMgr_processReceivedData+0x1c6>
abc: 10 92 bd 00 sts 0x00BD, r1
ac0: 10 92 be 00 sts 0x00BE, r1
ac4: 10 92 bc 00 sts 0x00BC, r1
ac8: f0 92 62 00 sts 0x0062, r15
acc: 26 c0 rjmp .+76 ; 0xb1a <UIMgr_processReceivedData+0x212>
ace: f6 de rcall .-532 ; 0x8bc <UIMgr_convertTokenToValue>
ad0: 80 91 bc 00 lds r24, 0x00BC
ad4: 8f 5f subi r24, 0xFF ; 255
ad6: 80 93 bc 00 sts 0x00BC, r24
ada: 1f c0 rjmp .+62 ; 0xb1a <UIMgr_processReceivedData+0x212>
adc: 89 2f mov r24, r25
ade: 81 54 subi r24, 0x41 ; 65
ae0: 8a 31 cpi r24, 0x1A ; 26
ae2: 18 f0 brcs .+6 ; 0xaea <UIMgr_processReceivedData+0x1e2>
ae4: 8f 5e subi r24, 0xEF ; 239
ae6: 8a 30 cpi r24, 0x0A ; 10
ae8: b0 f4 brcc .+44 ; 0xb16 <UIMgr_processReceivedData+0x20e>
aea: 80 91 be 00 lds r24, 0x00BE
aee: e8 2f mov r30, r24
af0: ff 27 eor r31, r31
af2: e1 54 subi r30, 0x41 ; 65
af4: ff 4f sbci r31, 0xFF ; 255
af6: 90 83 st Z, r25
af8: 90 91 bd 00 lds r25, 0x00BD
afc: 9f 5f subi r25, 0xFF ; 255
afe: 90 93 bd 00 sts 0x00BD, r25
b02: 8f 5f subi r24, 0xFF ; 255
b04: 80 93 be 00 sts 0x00BE, r24
b08: 94 30 cpi r25, 0x04 ; 4
b0a: 38 f0 brcs .+14 ; 0xb1a <UIMgr_processReceivedData+0x212>
b0c: f0 92 62 00 sts 0x0062, r15
b10: 10 92 be 00 sts 0x00BE, r1
b14: 02 c0 rjmp .+4 ; 0xb1a <UIMgr_processReceivedData+0x212>
b16: f0 92 62 00 sts 0x0062, r15
b1a: 20 91 b9 00 lds r18, 0x00B9
b1e: 80 91 b8 00 lds r24, 0x00B8
b22: 82 17 cp r24, r18
b24: 09 f0 breq .+2 ; 0xb28 <UIMgr_processReceivedData+0x220>
b26: fa ce rjmp .-524 ; 0x91c <UIMgr_processReceivedData+0x14>
b28: e8 94 clt
b2a: df 91 pop r29
b2c: cf 91 pop r28
b2e: 1f 91 pop r17
b30: 0f 91 pop r16
b32: ff 90 pop r15
b34: 08 95 ret
00000b36 <UIMgr_dispatchEvent>:
b36: 80 31 cpi r24, 0x10 ; 16
b38: 29 f0 breq .+10 ; 0xb44 <UIMgr_dispatchEvent+0xe>
b3a: 80 39 cpi r24, 0x90 ; 144
b3c: 39 f0 breq .+14 ; 0xb4c <UIMgr_dispatchEvent+0x16>
b3e: 81 30 cpi r24, 0x01 ; 1
b40: 31 f4 brne .+12 ; 0xb4e <UIMgr_dispatchEvent+0x18>
b42: 02 c0 rjmp .+4 ; 0xb48 <UIMgr_dispatchEvent+0x12>
b44: 38 de rcall .-912 ; 0x7b6 <UIMgr_transmitPendingData>
b46: 08 95 ret
b48: df de rcall .-578 ; 0x908 <UIMgr_processReceivedData>
b4a: 08 95 ret
b4c: 0e de rcall .-996 ; 0x76a <UIMgr_flushTxBuffer>
b4e: 08 95 ret
00000b50 <UartInt_init>:
b50: 10 bc out 0x20, r1 ; 32
b52: 82 e1 ldi r24, 0x12 ; 18
b54: 89 b9 out 0x09, r24 ; 9
b56: 88 e9 ldi r24, 0x98 ; 152
b58: 8a b9 out 0x0a, r24 ; 10
b5a: 86 e8 ldi r24, 0x86 ; 134
b5c: 80 bd out 0x20, r24 ; 32
b5e: 82 e0 ldi r24, 0x02 ; 2
b60: 8b b9 out 0x0b, r24 ; 11
b62: 08 95 ret
00000b64 <UartInt_txByte>:
b64: 5d 9b sbis 0x0b, 5 ; 11
b66: fe cf rjmp .-4 ; 0xb64 <UartInt_txByte>
b68: 8c b9 out 0x0c, r24 ; 12
b6a: 08 95 ret
00000b6c <__vector_11>:
b6c: 1f 92 push r1
b6e: 0f 92 push r0
b70: 0f b6 in r0, 0x3f ; 63
b72: 0f 92 push r0
b74: 11 24 eor r1, r1
b76: 8f 93 push r24
b78: 9f 93 push r25
b7a: ef 93 push r30
b7c: ff 93 push r31
b7e: 80 91 b8 00 lds r24, 0x00B8
b82: 9c b1 in r25, 0x0c ; 12
b84: e4 e7 ldi r30, 0x74 ; 116
b86: f2 e0 ldi r31, 0x02 ; 2
b88: e8 0f add r30, r24
b8a: f1 1d adc r31, r1
b8c: 90 83 st Z, r25
b8e: 8f 5f subi r24, 0xFF ; 255
b90: 8f 71 andi r24, 0x1F ; 31
b92: 80 93 b8 00 sts 0x00B8, r24
b96: 80 91 70 00 lds r24, 0x0070
b9a: ec e6 ldi r30, 0x6C ; 108
b9c: f2 e0 ldi r31, 0x02 ; 2
b9e: e8 0f add r30, r24
ba0: f1 1d adc r31, r1
ba2: 91 e0 ldi r25, 0x01 ; 1
ba4: 90 83 st Z, r25
ba6: 8f 5f subi r24, 0xFF ; 255
ba8: 87 70 andi r24, 0x07 ; 7
baa: 80 93 70 00 sts 0x0070, r24
bae: ff 91 pop r31
bb0: ef 91 pop r30
bb2: 9f 91 pop r25
bb4: 8f 91 pop r24
bb6: 0f 90 pop r0
bb8: 0f be out 0x3f, r0 ; 63
bba: 0f 90 pop r0
bbc: 1f 90 pop r1
bbe: 18 95 reti
00000bc0 <I2CInt_init>:
bc0: 11 b8 out 0x01, r1 ; 1
bc2: 88 e4 ldi r24, 0x48 ; 72
bc4: 80 b9 out 0x00, r24 ; 0
bc6: 08 95 ret
00000bc8 <I2CInt_writeData>:
bc8: 98 2f mov r25, r24
bca: 80 91 08 01 lds r24, 0x0108
bce: 88 23 and r24, r24
bd0: e4 f3 brlt .-8 ; 0xbca <I2CInt_writeData+0x2>
bd2: 06 b6 in r0, 0x36 ; 54
bd4: 04 fc sbrc r0, 4
bd6: fd cf rjmp .-6 ; 0xbd2 <I2CInt_writeData+0xa>
bd8: 90 93 03 01 sts 0x0103, r25
bdc: 70 93 05 01 sts 0x0105, r23
be0: 60 93 04 01 sts 0x0104, r22
be4: 40 93 07 01 sts 0x0107, r20
be8: 10 92 06 01 sts 0x0106, r1
bec: 10 92 09 01 sts 0x0109, r1
bf0: 85 ea ldi r24, 0xA5 ; 165
bf2: 86 bf out 0x36, r24 ; 54
bf4: 80 91 08 01 lds r24, 0x0108
bf8: 80 68 ori r24, 0x80 ; 128
bfa: 80 93 08 01 sts 0x0108, r24
bfe: 08 95 ret
00000c00 <I2CInt_readData>:
c00: 98 2f mov r25, r24
c02: 80 91 08 01 lds r24, 0x0108
c06: 88 23 and r24, r24
c08: e4 f3 brlt .-8 ; 0xc02 <I2CInt_readData+0x2>
c0a: 90 93 03 01 sts 0x0103, r25
c0e: 70 93 05 01 sts 0x0105, r23
c12: 60 93 04 01 sts 0x0104, r22
c16: 40 93 07 01 sts 0x0107, r20
c1a: 81 e0 ldi r24, 0x01 ; 1
c1c: 80 93 06 01 sts 0x0106, r24
c20: 10 92 09 01 sts 0x0109, r1
c24: 85 ea ldi r24, 0xA5 ; 165
c26: 86 bf out 0x36, r24 ; 54
c28: 80 91 08 01 lds r24, 0x0108
c2c: 80 68 ori r24, 0x80 ; 128
c2e: 80 93 08 01 sts 0x0108, r24
c32: 08 95 ret
00000c34 <I2CInt_isI2cBusy>:
c34: 80 91 08 01 lds r24, 0x0108
c38: 88 1f adc r24, r24
c3a: 88 27 eor r24, r24
c3c: 88 1f adc r24, r24
c3e: 99 27 eor r25, r25
c40: 08 95 ret
00000c42 <__vector_17>:
c42: 1f 92 push r1
c44: 0f 92 push r0
c46: 0f b6 in r0, 0x3f ; 63
c48: 0f 92 push r0
c4a: 11 24 eor r1, r1
c4c: 8f 93 push r24
c4e: 9f 93 push r25
c50: af 93 push r26
c52: bf 93 push r27
c54: ef 93 push r30
c56: ff 93 push r31
c58: 81 b1 in r24, 0x01 ; 1
c5a: 99 27 eor r25, r25
c5c: aa 27 eor r26, r26
c5e: bb 27 eor r27, r27
c60: 88 7f andi r24, 0xF8 ; 248
c62: 90 70 andi r25, 0x00 ; 0
c64: a0 70 andi r26, 0x00 ; 0
c66: b0 70 andi r27, 0x00 ; 0
c68: fc 01 movw r30, r24
c6a: 38 97 sbiw r30, 0x08 ; 8
c6c: e1 35 cpi r30, 0x51 ; 81
c6e: f1 05 cpc r31, r1
c70: 08 f0 brcs .+2 ; 0xc74 <__vector_17+0x32>
c72: 9a c0 rjmp .+308 ; 0xda8 <__vector_17+0x166>
c74: ed 5e subi r30, 0xED ; 237
c76: ff 4f sbci r31, 0xFF ; 255
c78: 09 94 ijmp
c7a: 80 91 09 01 lds r24, 0x0109
c7e: 83 30 cpi r24, 0x03 ; 3
c80: 48 f0 brcs .+18 ; 0xc94 <__vector_17+0x52>
c82: 86 b7 in r24, 0x36 ; 54
c84: 80 69 ori r24, 0x90 ; 144
c86: 86 bf out 0x36, r24 ; 54
c88: 80 91 08 01 lds r24, 0x0108
c8c: 8f 77 andi r24, 0x7F ; 127
c8e: 80 93 08 01 sts 0x0108, r24
c92: 8a c0 rjmp .+276 ; 0xda8 <__vector_17+0x166>
c94: 80 91 03 01 lds r24, 0x0103
c98: 90 91 06 01 lds r25, 0x0106
c9c: 88 0f add r24, r24
c9e: 89 0f add r24, r25
ca0: 83 b9 out 0x03, r24 ; 3
ca2: 86 b7 in r24, 0x36 ; 54
ca4: 8f 7d andi r24, 0xDF ; 223
ca6: 86 bf out 0x36, r24 ; 54
ca8: 7f c0 rjmp .+254 ; 0xda8 <__vector_17+0x166>
caa: 10 92 09 01 sts 0x0109, r1
cae: e0 91 04 01 lds r30, 0x0104
cb2: f0 91 05 01 lds r31, 0x0105
cb6: 80 81 ld r24, Z
cb8: 83 b9 out 0x03, r24 ; 3
cba: 31 96 adiw r30, 0x01 ; 1
cbc: f0 93 05 01 sts 0x0105, r31
cc0: e0 93 04 01 sts 0x0104, r30
cc4: 86 b7 in r24, 0x36 ; 54
cc6: 80 68 ori r24, 0x80 ; 128
cc8: 86 bf out 0x36, r24 ; 54
cca: 6e c0 rjmp .+220 ; 0xda8 <__vector_17+0x166>
ccc: 80 91 09 01 lds r24, 0x0109
cd0: 8f 5f subi r24, 0xFF ; 255
cd2: 80 93 09 01 sts 0x0109, r24
cd6: 86 b7 in r24, 0x36 ; 54
cd8: 80 6b ori r24, 0xB0 ; 176
cda: 86 bf out 0x36, r24 ; 54
cdc: 65 c0 rjmp .+202 ; 0xda8 <__vector_17+0x166>
cde: 80 91 07 01 lds r24, 0x0107
ce2: 81 50 subi r24, 0x01 ; 1
ce4: 80 93 07 01 sts 0x0107, r24
ce8: 80 91 07 01 lds r24, 0x0107
cec: 88 23 and r24, r24
cee: 79 f0 breq .+30 ; 0xd0e <__vector_17+0xcc>
cf0: e0 91 04 01 lds r30, 0x0104
cf4: f0 91 05 01 lds r31, 0x0105
cf8: 80 81 ld r24, Z
cfa: 83 b9 out 0x03, r24 ; 3
cfc: 31 96 adiw r30, 0x01 ; 1
cfe: f0 93 05 01 sts 0x0105, r31
d02: e0 93 04 01 sts 0x0104, r30
d06: 86 b7 in r24, 0x36 ; 54
d08: 80 68 ori r24, 0x80 ; 128
d0a: 86 bf out 0x36, r24 ; 54
d0c: 4d c0 rjmp .+154 ; 0xda8 <__vector_17+0x166>
d0e: 86 b7 in r24, 0x36 ; 54
d10: 80 69 ori r24, 0x90 ; 144
d12: 86 bf out 0x36, r24 ; 54
d14: 80 91 08 01 lds r24, 0x0108
d18: 8f 77 andi r24, 0x7F ; 127
d1a: 80 93 08 01 sts 0x0108, r24
d1e: 44 c0 rjmp .+136 ; 0xda8 <__vector_17+0x166>
d20: 86 b7 in r24, 0x36 ; 54
d22: 80 69 ori r24, 0x90 ; 144
d24: 86 bf out 0x36, r24 ; 54
d26: 80 91 08 01 lds r24, 0x0108
d2a: 8f 77 andi r24, 0x7F ; 127
d2c: 80 93 08 01 sts 0x0108, r24
d30: 3b c0 rjmp .+118 ; 0xda8 <__vector_17+0x166>
d32: 80 91 07 01 lds r24, 0x0107
d36: 81 50 subi r24, 0x01 ; 1
d38: 80 93 07 01 sts 0x0107, r24
d3c: 80 91 07 01 lds r24, 0x0107
d40: 88 23 and r24, r24
d42: 21 f0 breq .+8 ; 0xd4c <__vector_17+0x10a>
d44: 86 b7 in r24, 0x36 ; 54
d46: 80 6c ori r24, 0xC0 ; 192
d48: 86 bf out 0x36, r24 ; 54
d4a: 2e c0 rjmp .+92 ; 0xda8 <__vector_17+0x166>
d4c: 86 b7 in r24, 0x36 ; 54
d4e: 80 68 ori r24, 0x80 ; 128
d50: 86 bf out 0x36, r24 ; 54
d52: 2a c0 rjmp .+84 ; 0xda8 <__vector_17+0x166>
d54: e0 91 04 01 lds r30, 0x0104
d58: f0 91 05 01 lds r31, 0x0105
d5c: 83 b1 in r24, 0x03 ; 3
d5e: 80 83 st Z, r24
d60: 31 96 adiw r30, 0x01 ; 1
d62: f0 93 05 01 sts 0x0105, r31
d66: e0 93 04 01 sts 0x0104, r30
d6a: 80 91 07 01 lds r24, 0x0107
d6e: 81 50 subi r24, 0x01 ; 1
d70: 80 93 07 01 sts 0x0107, r24
d74: 80 91 07 01 lds r24, 0x0107
d78: 88 23 and r24, r24
d7a: 21 f0 breq .+8 ; 0xd84 <__vector_17+0x142>
d7c: 86 b7 in r24, 0x36 ; 54
d7e: 80 6c ori r24, 0xC0 ; 192
d80: 86 bf out 0x36, r24 ; 54
d82: 12 c0 rjmp .+36 ; 0xda8 <__vector_17+0x166>
d84: 86 b7 in r24, 0x36 ; 54
d86: 8f 7b andi r24, 0xBF ; 191
d88: 86 bf out 0x36, r24 ; 54
d8a: 0e c0 rjmp .+28 ; 0xda8 <__vector_17+0x166>
d8c: e0 91 04 01 lds r30, 0x0104
d90: f0 91 05 01 lds r31, 0x0105
d94: 83 b1 in r24, 0x03 ; 3
d96: 80 83 st Z, r24
d98: 86 b7 in r24, 0x36 ; 54
d9a: 80 69 ori r24, 0x90 ; 144
d9c: 86 bf out 0x36, r24 ; 54
d9e: 80 91 08 01 lds r24, 0x0108
da2: 8f 77 andi r24, 0x7F ; 127
da4: 80 93 08 01 sts 0x0108, r24
da8: ff 91 pop r31
daa: ef 91 pop r30
dac: bf 91 pop r27
dae: af 91 pop r26
db0: 9f 91 pop r25
db2: 8f 91 pop r24
db4: 0f 90 pop r0
db6: 0f be out 0x3f, r0 ; 63
db8: 0f 90 pop r0
dba: 1f 90 pop r1
dbc: 18 95 reti
00000dbe <CamConfig_writeTxFifo>:
dbe: 20 91 0a 01 lds r18, 0x010A
dc2: e2 2f mov r30, r18
dc4: ff 27 eor r31, r31
dc6: ee 0f add r30, r30
dc8: ff 1f adc r31, r31
dca: ec 52 subi r30, 0x2C ; 44
dcc: fd 4f sbci r31, 0xFD ; 253
dce: 91 83 std Z+1, r25 ; 0x01
dd0: 80 83 st Z, r24
dd2: 2f 5f subi r18, 0xFF ; 255
dd4: 27 70 andi r18, 0x07 ; 7
dd6: 20 93 0a 01 sts 0x010A, r18
dda: 90 e0 ldi r25, 0x00 ; 0
ddc: 80 91 0b 01 lds r24, 0x010B
de0: 28 17 cp r18, r24
de2: 09 f4 brne .+2 ; 0xde6 <CamConfig_writeTxFifo+0x28>
de4: 91 e0 ldi r25, 0x01 ; 1
de6: 81 e0 ldi r24, 0x01 ; 1
de8: 89 27 eor r24, r25
dea: 99 27 eor r25, r25
dec: 08 95 ret
00000dee <CamConfig_setCamReg>:
dee: 28 2f mov r18, r24
df0: 36 2f mov r19, r22
df2: c9 01 movw r24, r18
df4: e4 df rcall .-56 ; 0xdbe <CamConfig_writeTxFifo>
df6: 08 95 ret
00000df8 <CamConfig_sendFifoCmds>:
df8: 0f 93 push r16
dfa: 1f 93 push r17
dfc: cf 93 push r28
dfe: df 93 push r29
e00: cd b7 in r28, 0x3d ; 61
e02: de b7 in r29, 0x3e ; 62
e04: 22 97 sbiw r28, 0x02 ; 2
e06: 0f b6 in r0, 0x3f ; 63
e08: f8 94 cli
e0a: de bf out 0x3e, r29 ; 62
e0c: 0f be out 0x3f, r0 ; 63
e0e: cd bf out 0x3d, r28 ; 61
e10: 8e 01 movw r16, r28
e12: 0f 5f subi r16, 0xFF ; 255
e14: 1f 4f sbci r17, 0xFF ; 255
e16: 19 c0 rjmp .+50 ; 0xe4a <CamConfig_sendFifoCmds+0x52>
e18: e3 2f mov r30, r19
e1a: ff 27 eor r31, r31
e1c: ee 0f add r30, r30
e1e: ff 1f adc r31, r31
e20: ec 52 subi r30, 0x2C ; 44
e22: fd 4f sbci r31, 0xFD ; 253
e24: 91 81 ldd r25, Z+1 ; 0x01
e26: 20 81 ld r18, Z
e28: 83 2f mov r24, r19
e2a: 8f 5f subi r24, 0xFF ; 255
e2c: 87 70 andi r24, 0x07 ; 7
e2e: 80 93 0b 01 sts 0x010B, r24
e32: 9a 83 std Y+2, r25 ; 0x02
e34: 29 83 std Y+1, r18 ; 0x01
e36: 42 e0 ldi r20, 0x02 ; 2
e38: b8 01 movw r22, r16
e3a: 80 e6 ldi r24, 0x60 ; 96
e3c: c5 de rcall .-630 ; 0xbc8 <I2CInt_writeData>
e3e: 84 e6 ldi r24, 0x64 ; 100
e40: 90 e0 ldi r25, 0x00 ; 0
e42: 25 d0 rcall .+74 ; 0xe8e <Utility_delay>
e44: f7 de rcall .-530 ; 0xc34 <I2CInt_isI2cBusy>
e46: 81 30 cpi r24, 0x01 ; 1
e48: e9 f3 breq .-6 ; 0xe44 <CamConfig_sendFifoCmds+0x4c>
e4a: 30 91 0b 01 lds r19, 0x010B
e4e: 80 91 0a 01 lds r24, 0x010A
e52: 83 17 cp r24, r19
e54: 09 f7 brne .-62 ; 0xe18 <CamConfig_sendFifoCmds+0x20>
e56: 22 96 adiw r28, 0x02 ; 2
e58: 0f b6 in r0, 0x3f ; 63
e5a: f8 94 cli
e5c: de bf out 0x3e, r29 ; 62
e5e: 0f be out 0x3f, r0 ; 63
e60: cd bf out 0x3d, r28 ; 61
e62: df 91 pop r29
e64: cf 91 pop r28
e66: 1f 91 pop r17
e68: 0f 91 pop r16
e6a: 08 95 ret
00000e6c <CamConfig_init>:
e6c: 60 e2 ldi r22, 0x20 ; 32
e6e: 84 e1 ldi r24, 0x14 ; 20
e70: be df rcall .-132 ; 0xdee <CamConfig_setCamReg>
e72: 60 e4 ldi r22, 0x40 ; 64
e74: 89 e3 ldi r24, 0x39 ; 57
e76: bb df rcall .-138 ; 0xdee <CamConfig_setCamReg>
e78: 68 e2 ldi r22, 0x28 ; 40
e7a: 82 e1 ldi r24, 0x12 ; 18
e7c: b8 df rcall .-144 ; 0xdee <CamConfig_setCamReg>
e7e: 65 e0 ldi r22, 0x05 ; 5
e80: 88 e2 ldi r24, 0x28 ; 40
e82: b5 df rcall .-150 ; 0xdee <CamConfig_setCamReg>
e84: 61 e0 ldi r22, 0x01 ; 1
e86: 83 e1 ldi r24, 0x13 ; 19
e88: b2 df rcall .-156 ; 0xdee <CamConfig_setCamReg>
e8a: b6 df rcall .-148 ; 0xdf8 <CamConfig_sendFifoCmds>
e8c: 08 95 ret
00000e8e <Utility_delay>:
e8e: cf 93 push r28
e90: df 93 push r29
e92: cd b7 in r28, 0x3d ; 61
e94: de b7 in r29, 0x3e ; 62
e96: 24 97 sbiw r28, 0x04 ; 4
e98: 0f b6 in r0, 0x3f ; 63
e9a: f8 94 cli
e9c: de bf out 0x3e, r29 ; 62
e9e: 0f be out 0x3f, r0 ; 63
ea0: cd bf out 0x3d, r28 ; 61
ea2: 9c 01 movw r18, r24
ea4: 1a 82 std Y+2, r1 ; 0x02
ea6: 19 82 std Y+1, r1 ; 0x01
ea8: 1c 82 std Y+4, r1 ; 0x04
eaa: 1b 82 std Y+3, r1 ; 0x03
eac: 1a 82 std Y+2, r1 ; 0x02
eae: 19 82 std Y+1, r1 ; 0x01
eb0: 89 81 ldd r24, Y+1 ; 0x01
eb2: 9a 81 ldd r25, Y+2 ; 0x02
eb4: 82 17 cp r24, r18
eb6: 93 07 cpc r25, r19
eb8: e0 f4 brcc .+56 ; 0xef2 <Utility_delay+0x64>
eba: 1c 82 std Y+4, r1 ; 0x04
ebc: 1b 82 std Y+3, r1 ; 0x03
ebe: 8b 81 ldd r24, Y+3 ; 0x03
ec0: 9c 81 ldd r25, Y+4 ; 0x04
ec2: 88 5e subi r24, 0xE8 ; 232
ec4: 93 40 sbci r25, 0x03 ; 3
ec6: 58 f4 brcc .+22 ; 0xede <Utility_delay+0x50>
ec8: 00 00 nop
eca: 8b 81 ldd r24, Y+3 ; 0x03
ecc: 9c 81 ldd r25, Y+4 ; 0x04
ece: 01 96 adiw r24, 0x01 ; 1
ed0: 9c 83 std Y+4, r25 ; 0x04
ed2: 8b 83 std Y+3, r24 ; 0x03
ed4: 8b 81 ldd r24, Y+3 ; 0x03
ed6: 9c 81 ldd r25, Y+4 ; 0x04
ed8: 88 5e subi r24, 0xE8 ; 232
eda: 93 40 sbci r25, 0x03 ; 3
edc: a8 f3 brcs .-22 ; 0xec8 <Utility_delay+0x3a>
ede: 89 81 ldd r24, Y+1 ; 0x01
ee0: 9a 81 ldd r25, Y+2 ; 0x02
ee2: 01 96 adiw r24, 0x01 ; 1
ee4: 9a 83 std Y+2, r25 ; 0x02
ee6: 89 83 std Y+1, r24 ; 0x01
ee8: 89 81 ldd r24, Y+1 ; 0x01
eea: 9a 81 ldd r25, Y+2 ; 0x02
eec: 82 17 cp r24, r18
eee: 93 07 cpc r25, r19
ef0: 20 f3 brcs .-56 ; 0xeba <Utility_delay+0x2c>
ef2: 24 96 adiw r28, 0x04 ; 4
ef4: 0f b6 in r0, 0x3f ; 63
ef6: f8 94 cli
ef8: de bf out 0x3e, r29 ; 62
efa: 0f be out 0x3f, r0 ; 63
efc: cd bf out 0x3d, r28 ; 61
efe: df 91 pop r29
f00: cf 91 pop r28
f02: 08 95 ret
00000f04 <DebugInt_init>:
f04: 8e 9a sbi 0x11, 6 ; 17
f06: 96 9a sbi 0x12, 6 ; 18
f08: 84 ef ldi r24, 0xF4 ; 244
f0a: 91 e0 ldi r25, 0x01 ; 1
f0c: c0 df rcall .-128 ; 0xe8e <Utility_delay>
f0e: 96 98 cbi 0x12, 6 ; 18
f10: 84 ef ldi r24, 0xF4 ; 244
f12: 91 e0 ldi r25, 0x01 ; 1
f14: bc df rcall .-136 ; 0xe8e <Utility_delay>
f16: 96 9a sbi 0x12, 6 ; 18
f18: 84 ef ldi r24, 0xF4 ; 244
f1a: 91 e0 ldi r25, 0x01 ; 1
f1c: b8 df rcall .-144 ; 0xe8e <Utility_delay>
f1e: 96 98 cbi 0x12, 6 ; 18
f20: 84 ef ldi r24, 0xF4 ; 244
f22: 91 e0 ldi r25, 0x01 ; 1
f24: b4 df rcall .-152 ; 0xe8e <Utility_delay>
f26: 96 9a sbi 0x12, 6 ; 18
f28: 84 ef ldi r24, 0xF4 ; 244
f2a: 91 e0 ldi r25, 0x01 ; 1
f2c: b0 df rcall .-160 ; 0xe8e <Utility_delay>
f2e: 96 98 cbi 0x12, 6 ; 18
f30: 84 ef ldi r24, 0xF4 ; 244
f32: 91 e0 ldi r25, 0x01 ; 1
f34: ac df rcall .-168 ; 0xe8e <Utility_delay>
f36: 96 9a sbi 0x12, 6 ; 18
f38: 08 95 ret
00000f3a <CamIntAsm_waitForNewTrackingFrame>:
; set, and the function will return.
;*****************************************************************
CamIntAsm_waitForNewTrackingFrame:
sbi _SFR_IO_ADDR(PORTD),PD6 ; For testing...
f04: 96 9a sbi 0x12, 6 ; 18
f3a: 96 9a sbi 0x12, 6 ; 18
cbi _SFR_IO_ADDR(PORTD),PD6
f06: 96 98 cbi 0x12, 6 ; 18
f3c: 96 98 cbi 0x12, 6 ; 18
sleep
f08: 88 95 sleep
f3e: 88 95 sleep
00000f40 <CamIntAsm_acquireTrackingLine>:
00000f0a <CamIntAsm_acquireTrackingLine>:
;*****************************************************************
; REMEMBER...everything from here on out is critically timed to be
; synchronized with the flow of pixel data from the camera...
3687,68 → 2250,68
CamIntAsm_acquireTrackingLine:
brts _cleanUp
f0a: e6 f1 brts .+120 ; 0xf84
f40: e6 f1 brts .+120 ; 0xfba <_cleanUp>
;sbi _SFR_IO_ADDR(PORTD),PD6 ; For testing...
;cbi _SFR_IO_ADDR(PORTD),PD6
in tmp1,_SFR_IO_ADDR(TCCR1B) ; Enable the PCLK line to actually
f0c: 3e b5 in r19, 0x2e ; 46
f42: 3e b5 in r19, 0x2e ; 46
ori tmp1, 0x07 ; feed Timer1
f0e: 37 60 ori r19, 0x07 ; 7
f44: 37 60 ori r19, 0x07 ; 7
out _SFR_IO_ADDR(TCCR1B),tmp1
f10: 3e bd out 0x2e, r19 ; 46
f46: 3e bd out 0x2e, r19 ; 46
; The line is about to start...
ldi pixelCount,0 ; Initialize the RLE stats...
f12: 00 e0 ldi r16, 0x00 ; 0
f48: 00 e0 ldi r16, 0x00 ; 0
ldi pixelRunStart,PIXEL_RUN_START_INITIAL ; Remember, we always calculate
f14: 10 e5 ldi r17, 0x50 ; 80
f4a: 10 e5 ldi r17, 0x50 ; 80
; the pixel run length as
; TCNT1L - pixelRunStart
ldi lastColor,0x00 ; clear out the last color before we start
f16: 20 e0 ldi r18, 0x00 ; 0
f4c: 20 e0 ldi r18, 0x00 ; 0
mov XH,currLineBuffHigh ; Load the pointer to the current line
f18: b9 2f mov r27, r25
f4e: b9 2f mov r27, r25
mov XL,currLineBuffLow ; buffer into the X pointer regs
f1a: a8 2f mov r26, r24
f50: a8 2f mov r26, r24
mov ZH,colorMapHigh ; Load the pointers to the membership
f1c: f7 2f mov r31, r23
f52: f7 2f mov r31, r23
mov ZL,colorMapLow ; lookup tables (ZL and YL will be overwritten
f1e: e6 2f mov r30, r22
f54: e6 2f mov r30, r22
mov YH,colorMapHigh ; as soon as we start reading data) to Z and Y
f20: d7 2f mov r29, r23
f56: d7 2f mov r29, r23
in tmp1, _SFR_IO_ADDR(TIMSK) ; enable TIMER1 to start counting
f22: 39 b7 in r19, 0x39 ; 57
f58: 39 b7 in r19, 0x39 ; 57
ori tmp1, ENABLE_PCLK_TIMER1_OVERFLOW_BITMASK ; external PCLK pulses and interrupt on
f24: 34 60 ori r19, 0x04 ; 4
f5a: 34 60 ori r19, 0x04 ; 4
out _SFR_IO_ADDR(TIMSK),tmp1 ; overflow
f26: 39 bf out 0x39, r19 ; 57
f5c: 39 bf out 0x39, r19 ; 57
ldi tmp1,PIXEL_RUN_START_INITIAL ; set up the TCNT1 to overflow (and
f28: 30 e5 ldi r19, 0x50 ; 80
f5e: 30 e5 ldi r19, 0x50 ; 80
ldi tmp2,0xFF ; interrupts) after 176 pixels
f2a: 4f ef ldi r20, 0xFF ; 255
f60: 4f ef ldi r20, 0xFF ; 255
out _SFR_IO_ADDR(TCNT1H),tmp2
f2c: 4d bd out 0x2d, r20 ; 45
f62: 4d bd out 0x2d, r20 ; 45
out _SFR_IO_ADDR(TCNT1L),tmp1
f2e: 3c bd out 0x2c, r19 ; 44
f64: 3c bd out 0x2c, r19 ; 44
mov YL,colorMapLow
f30: c6 2f mov r28, r22
f66: c6 2f mov r28, r22
in tmp1, _SFR_IO_ADDR(GICR) ; enable the HREF interrupt...remember, we
f32: 3b b7 in r19, 0x3b ; 59
f68: 3b b7 in r19, 0x3b ; 59
; only use this interrupt to synchronize
; the beginning of the line
ori tmp1, HREF_INTERRUPT_ENABLE_MASK
f34: 30 68 ori r19, 0x80 ; 128
f6a: 30 68 ori r19, 0x80 ; 128
out _SFR_IO_ADDR(GICR), tmp1
f36: 3b bf out 0x3b, r19 ; 59
00000f38 <_trackFrame>:
f6c: 3b bf out 0x3b, r19 ; 59
00000f6e <_trackFrame>:
;*******************************************************************************************
; Track Frame handler
3756,9 → 2319,9
_trackFrame:
sbi _SFR_IO_ADDR(PORTD),PD6
f38: 96 9a sbi 0x12, 6 ; 18
f6e: 96 9a sbi 0x12, 6 ; 18
sleep ; ...And we wait...
f3a: 88 95 sleep
f70: 88 95 sleep
; Returning from the interrupt/sleep wakeup will consume
; 14 clock cycles (7 to wakeup from idle sleep, 3 to vector, and 4 to return)
3765,50 → 2328,50
; Disable the HREF interrupt
cbi _SFR_IO_ADDR(PORTD),PD6
f3c: 96 98 cbi 0x12, 6 ; 18
f72: 96 98 cbi 0x12, 6 ; 18
in tmp1, _SFR_IO_ADDR(GICR)
f3e: 3b b7 in r19, 0x3b ; 59
f74: 3b b7 in r19, 0x3b ; 59
andi tmp1, HREF_INTERRUPT_DISABLE_MASK
f40: 3f 77 andi r19, 0x7F ; 127
f76: 3f 77 andi r19, 0x7F ; 127
out _SFR_IO_ADDR(GICR), tmp1
f42: 3b bf out 0x3b, r19 ; 59
f78: 3b bf out 0x3b, r19 ; 59
; A couple of NOPs are needed here to sync up the pixel data...the number (2)
; of NOPs was determined emperically by trial and error.
nop
f44: 00 00 nop
...
00000f48 <_acquirePixelBlock>:
f7a: 00 00 nop
...
00000f7e <_acquirePixelBlock>:
nop
_acquirePixelBlock: ; Clock Cycle Count
in ZL,RB_PORT ; sample the red value (PINB) (1)
f48: e6 b3 in r30, 0x16 ; 22
f7e: e6 b3 in r30, 0x16 ; 22
in YL,G_PORT ; sample the green value (PINC) (1)
f4a: c3 b3 in r28, 0x13 ; 19
f80: c3 b3 in r28, 0x13 ; 19
andi YL,0x0F ; clear the high nibble (1)
f4c: cf 70 andi r28, 0x0F ; 15
f82: cf 70 andi r28, 0x0F ; 15
ldd color,Z+RED_MEM_OFFSET ; lookup the red membership (2)
f4e: 30 81 ld r19, Z
f84: 30 81 ld r19, Z
in ZL,RB_PORT ; sample the blue value (PINB) (1)
f50: e6 b3 in r30, 0x16 ; 22
f86: e6 b3 in r30, 0x16 ; 22
ldd greenData,Y+GREEN_MEM_OFFSET; lookup the green membership (2)
f52: 48 89 ldd r20, Y+16 ; 0x10
f88: 48 89 ldd r20, Y+16 ; 0x10
ldd blueData,Z+BLUE_MEM_OFFSET ; lookup the blue membership (2)
f54: 50 a1 ldd r21, Z+32 ; 0x20
f8a: 50 a1 ldd r21, Z+32 ; 0x20
and color,greenData ; mask memberships together (1)
f56: 34 23 and r19, r20
f8c: 34 23 and r19, r20
and color,blueData ; to produce the final color (1)
f58: 35 23 and r19, r21
f8e: 35 23 and r19, r21
brts _cleanUpTrackingLine ; if some interrupt routine has (1...not set)
f5a: 76 f0 brts .+28 ; 0xf78
f90: 76 f0 brts .+28 ; 0xfae <_cleanUpTrackingLine>
; come in and set our T flag in
; SREG, then we need to hop out
; and blow away this frames data (common cleanup)
cp color,lastColor ; check to see if the run continues (1)
f5c: 32 17 cp r19, r18
f92: 32 17 cp r19, r18
breq _acquirePixelBlock ; (2...equal)
f5e: a1 f3 breq .-24 ; 0xf48
f94: a1 f3 breq .-24 ; 0xf7e <_acquirePixelBlock>
; ___________
; 16 clock cycles
; (16 clock cycles = 1 uS = 1 pixelBlock time)
3815,57 → 2378,57
; Toggle the debug line to indicate a color change
sbi _SFR_IO_ADDR(PORTD),PD6
f60: 96 9a sbi 0x12, 6 ; 18
f96: 96 9a sbi 0x12, 6 ; 18
nop
f62: 00 00 nop
f98: 00 00 nop
cbi _SFR_IO_ADDR(PORTD),PD6
f64: 96 98 cbi 0x12, 6 ; 18
f9a: 96 98 cbi 0x12, 6 ; 18
mov tmp2,pixelRunStart ; get the count value of the
f66: 41 2f mov r20, r17
f9c: 41 2f mov r20, r17
; current pixel run
in pixelCount,_SFR_IO_ADDR(TCNT1L) ; get the current TCNT1 value
f68: 0c b5 in r16, 0x2c ; 44
f9e: 0c b5 in r16, 0x2c ; 44
mov pixelRunStart,pixelCount ; reload pixelRunStart for the
f6a: 10 2f mov r17, r16
fa0: 10 2f mov r17, r16
; next run
sub pixelCount,tmp2 ; pixelCount = TCNT1L - pixelRunStart
f6c: 04 1b sub r16, r20
fa2: 04 1b sub r16, r20
st X+,lastColor ; record the color run in the current line buffer
f6e: 2d 93 st X+, r18
fa4: 2d 93 st X+, r18
st X+,pixelCount ; with its length
f70: 0d 93 st X+, r16
fa6: 0d 93 st X+, r16
mov lastColor,color ; set lastColor so we can figure out when it changes
f72: 23 2f mov r18, r19
fa8: 23 2f mov r18, r19
nop ; waste one more cycle for a total of 16
f74: 00 00 nop
faa: 00 00 nop
rjmp _acquirePixelBlock
f76: e8 cf rjmp .-48 ; 0xf48
00000f78 <_cleanUpTrackingLine>:
fac: e8 cf rjmp .-48 ; 0xf7e <_acquirePixelBlock>
00000fae <_cleanUpTrackingLine>:
; _cleanUpTrackingLine is used to write the last run length block off to the currentLineBuffer so
; that all 176 pixels in the line are accounted for.
_cleanUpTrackingLine:
ldi pixelCount,0xFF ; the length of the last run is ALWAYS 0xFF minus the last
f78: 0f ef ldi r16, 0xFF ; 255
fae: 0f ef ldi r16, 0xFF ; 255
sub pixelCount,pixelRunStart ; pixelRunStart
f7a: 01 1b sub r16, r17
fb0: 01 1b sub r16, r17
inc pixelCount ; increment pixelCount since we actually need to account
f7c: 03 95 inc r16
fb2: 03 95 inc r16
; for the overflow of TCNT1
st X+,color ; record the color run in the current line buffer
f7e: 3d 93 st X+, r19
fb4: 3d 93 st X+, r19
st X,pixelCount
f80: 0c 93 st X, r16
fb6: 0c 93 st X, r16
rjmp _cleanUp
f82: 00 c0 rjmp .+0 ; 0xf84
00000f84 <_cleanUp>:
fb8: 00 c0 rjmp .+0 ; 0xfba <_cleanUp>
00000fba <_cleanUp>:
_cleanUpDumpLine:
; NOTE: If serial data is received, to interrupt the tracking of a line, we'll
3883,27 → 2446,27
_cleanUp:
; Disable the external clocking of the Timer1 counter
in tmp1, _SFR_IO_ADDR(TCCR1B)
f84: 3e b5 in r19, 0x2e ; 46
fba: 3e b5 in r19, 0x2e ; 46
andi tmp1, 0xF8
f86: 38 7f andi r19, 0xF8 ; 248
fbc: 38 7f andi r19, 0xF8 ; 248
out _SFR_IO_ADDR(TCCR1B),tmp1
f88: 3e bd out 0x2e, r19 ; 46
fbe: 3e bd out 0x2e, r19 ; 46
; Toggle the debug line to indicate the line is complete
sbi _SFR_IO_ADDR(PORTD),PD6
f8a: 96 9a sbi 0x12, 6 ; 18
fc0: 96 9a sbi 0x12, 6 ; 18
cbi _SFR_IO_ADDR(PORTD),PD6
f8c: 96 98 cbi 0x12, 6 ; 18
fc2: 96 98 cbi 0x12, 6 ; 18
clt ; clear out the T bit since we have detected
f8e: e8 94 clt
00000f90 <_exit>:
fc4: e8 94 clt
00000fc6 <_exit>:
; the interruption and are exiting to handle it
_exit:
ret
f90: 08 95 ret
00000f92 <CamIntAsm_waitForNewDumpFrame>:
fc6: 08 95 ret
00000fc8 <CamIntAsm_waitForNewDumpFrame>:
;*****************************************************************
; Function Name: CamIntAsm_waitForNewDumpFrame
3923,14 → 2486,14
;*****************************************************************
CamIntAsm_waitForNewDumpFrame:
sbi _SFR_IO_ADDR(PORTD),PD6 ; For testing...
f92: 96 9a sbi 0x12, 6 ; 18
fc8: 96 9a sbi 0x12, 6 ; 18
cbi _SFR_IO_ADDR(PORTD),PD6
f94: 96 98 cbi 0x12, 6 ; 18
fca: 96 98 cbi 0x12, 6 ; 18
sleep
f96: 88 95 sleep
fcc: 88 95 sleep
00000fce <CamIntAsm_acquireDumpLine>:
00000f98 <CamIntAsm_acquireDumpLine>:
;*****************************************************************
; REMEMBER...everything from here on out is critically timed to be
; synchronized with the flow of pixel data from the camera...
3938,55 → 2501,55
CamIntAsm_acquireDumpLine:
brts _cleanUp
f98: ae f3 brts .-22 ; 0xf84
fce: ae f3 brts .-22 ; 0xfba <_cleanUp>
;sbi _SFR_IO_ADDR(PORTD),PD6 ; For testing...
;cbi _SFR_IO_ADDR(PORTD),PD6
mov XH,currLineBuffHigh ; Load the pointer to the current line
f9a: b9 2f mov r27, r25
fd0: b9 2f mov r27, r25
mov XL,currLineBuffLow ; buffer into the X pointer regs
f9c: a8 2f mov r26, r24
fd2: a8 2f mov r26, r24
mov YH,prevLineBuffHigh ; Load the pointer to the previous line
f9e: d7 2f mov r29, r23
fd4: d7 2f mov r29, r23
mov YL,prevLineBuffLow ; buffer into the Y pointer regs
fa0: c6 2f mov r28, r22
fd6: c6 2f mov r28, r22
ldi tmp1,PIXEL_RUN_START_INITIAL ; set up the TCNT1 to overflow (and
fa2: 30 e5 ldi r19, 0x50 ; 80
fd8: 30 e5 ldi r19, 0x50 ; 80
ldi tmp2,0xFF ; interrupts) after 176 pixels
fa4: 4f ef ldi r20, 0xFF ; 255
fda: 4f ef ldi r20, 0xFF ; 255
out _SFR_IO_ADDR(TCNT1H),tmp2
fa6: 4d bd out 0x2d, r20 ; 45
fdc: 4d bd out 0x2d, r20 ; 45
out _SFR_IO_ADDR(TCNT1L),tmp1
fa8: 3c bd out 0x2c, r19 ; 44
fde: 3c bd out 0x2c, r19 ; 44
in tmp1, _SFR_IO_ADDR(TCCR1B) ; Enable the PCLK line to actually
faa: 3e b5 in r19, 0x2e ; 46
fe0: 3e b5 in r19, 0x2e ; 46
ori tmp1, 0x07 ; feed Timer1
fac: 37 60 ori r19, 0x07 ; 7
fe2: 37 60 ori r19, 0x07 ; 7
out _SFR_IO_ADDR(TCCR1B),tmp1
fae: 3e bd out 0x2e, r19 ; 46
fe4: 3e bd out 0x2e, r19 ; 46
nop
fb0: 00 00 nop
fe6: 00 00 nop
in tmp1, _SFR_IO_ADDR(TIMSK) ; enable TIMER1 to start counting
fb2: 39 b7 in r19, 0x39 ; 57
fe8: 39 b7 in r19, 0x39 ; 57
ori tmp1, ENABLE_PCLK_TIMER1_OVERFLOW_BITMASK ; external PCLK pulses and interrupt on
fb4: 34 60 ori r19, 0x04 ; 4
fea: 34 60 ori r19, 0x04 ; 4
out _SFR_IO_ADDR(TIMSK),tmp1 ; overflow
fb6: 39 bf out 0x39, r19 ; 57
fec: 39 bf out 0x39, r19 ; 57
in tmp1, _SFR_IO_ADDR(GICR) ; enable the HREF interrupt...remember, we
fb8: 3b b7 in r19, 0x3b ; 59
fee: 3b b7 in r19, 0x3b ; 59
; only use this interrupt to synchronize
; the beginning of the line
ori tmp1, HREF_INTERRUPT_ENABLE_MASK
fba: 30 68 ori r19, 0x80 ; 128
ff0: 30 68 ori r19, 0x80 ; 128
out _SFR_IO_ADDR(GICR), tmp1
fbc: 3b bf out 0x3b, r19 ; 59
00000fbe <_dumpFrame>:
ff2: 3b bf out 0x3b, r19 ; 59
00000ff4 <_dumpFrame>:
;*******************************************************************************************
; Dump Frame handler
3994,21 → 2557,21
_dumpFrame:
sbi _SFR_IO_ADDR(PORTD),PD6
fbe: 96 9a sbi 0x12, 6 ; 18
ff4: 96 9a sbi 0x12, 6 ; 18
sleep ; ...And we wait...
fc0: 88 95 sleep
ff6: 88 95 sleep
cbi _SFR_IO_ADDR(PORTD),PD6
fc2: 96 98 cbi 0x12, 6 ; 18
ff8: 96 98 cbi 0x12, 6 ; 18
in tmp1, _SFR_IO_ADDR(GICR) ; disable the HREF interrupt
fc4: 3b b7 in r19, 0x3b ; 59
ffa: 3b b7 in r19, 0x3b ; 59
andi tmp1, HREF_INTERRUPT_DISABLE_MASK ; so we don't get interrupted
fc6: 3f 77 andi r19, 0x7F ; 127
ffc: 3f 77 andi r19, 0x7F ; 127
out _SFR_IO_ADDR(GICR), tmp1 ; while dumping the line
fc8: 3b bf out 0x3b, r19 ; 59
...
00000fcc <_sampleDumpPixel>:
ffe: 3b bf out 0x3b, r19 ; 59
...
00001002 <_sampleDumpPixel>:
nop ; Remember...if we ever remove the "cbi" instruction above,
; we need to add two more NOPs to cover this
4023,15 → 2586,15
; do that here (only 8 instruction cycles :-) )
_sampleDumpPixel:
in tmp1,G_PORT ; sample the G value (1)
fcc: 33 b3 in r19, 0x13 ; 19
1002: 33 b3 in r19, 0x13 ; 19
in tmp2,RB_PORT ; sample the R/B value (1)
fce: 46 b3 in r20, 0x16 ; 22
1004: 46 b3 in r20, 0x16 ; 22
st X+,tmp1 ; store to the currLineBuff and inc ptrs(2)
fd0: 3d 93 st X+, r19
1006: 3d 93 st X+, r19
st Y+,tmp2 ; store to the prevLineBuff and inc ptrs(2)
fd2: 49 93 st Y+, r20
1008: 49 93 st Y+, r20
brtc _sampleDumpPixel ; loop back unless flag is set (2...if not set)
fd4: de f7 brtc .-10 ; 0xfcc
100a: de f7 brtc .-10 ; 0x1002 <_sampleDumpPixel>
; ___________
; 8 cycles normally
4038,10 → 2601,10
; if we make it here, it means the T flag is set, and we must have been interrupted
; so we need to exit (what if we were interrupted for serial? should we disable it?)
rjmp _cleanUpDumpLine
fd6: d6 cf rjmp .-84 ; 0xf84
100c: d6 cf rjmp .-84 ; 0xfba <_cleanUp>
0000100e <__vector_1>:
00000fd8 <__vector_1>:
;***********************************************************
; Function Name: <interrupt handler for External Interrupt0>
; Function Description: This function is responsible
4055,9 → 2618,9
SIG_INTERRUPT0:
; This will wake us up when VSYNC transitions high...we just want to return
reti
fd8: 18 95 reti
00000fda <__vector_2>:
100e: 18 95 reti
00001010 <__vector_2>:
;***********************************************************
; Function Name: <interrupt handler for External Interrupt1>
4073,9 → 2636,9
SIG_INTERRUPT1:
; This will wake us up when HREF transitions high...we just want to return
reti
fda: 18 95 reti
00000fdc <__vector_8>:
1010: 18 95 reti
00001012 <__vector_8>:
;***********************************************************
; Function Name: <interrupt handler for Timer0 overflow>
4111,143 → 2674,114
;***********************************************************
SIG_OVERFLOW1:
lds tmp1,fastEventBitmask ; set a flag indicating
fdc: 30 91 72 00 lds r19, 0x0072
1012: 30 91 72 00 lds r19, 0x0072
ori tmp1,FEV_ACQUIRE_LINE_COMPLETE ; a line is complete
fe0: 31 60 ori r19, 0x01 ; 1
1016: 31 60 ori r19, 0x01 ; 1
sts fastEventBitmask,tmp1
fe2: 30 93 72 00 sts 0x0072, r19
1018: 30 93 72 00 sts 0x0072, r19
set ; set the T bit in SREG
fe6: 68 94 set
101c: 68 94 set
;sbi _SFR_IO_ADDR(PORTD),PD6 ; For testing...
;cbi _SFR_IO_ADDR(PORTD),PD6 ; For testing...
reti
fe8: 18 95 reti
101e: 18 95 reti
00001020 <__vector_default>:
00000fea <__vector_default>:
; This is the default handler for all interrupts that don't
; have handler routines specified for them.
.global __vector_default
__vector_default:
reti
fea: 18 95 reti
00000fec <atoi>:
fec: fc 01 movw r30, r24
fee: 88 27 eor r24, r24
ff0: 99 27 eor r25, r25
ff2: e8 94 clt
00000ff4 <.atoi_loop>:
ff4: 21 91 ld r18, Z+
ff6: 22 23 and r18, r18
ff8: e9 f0 breq .+58 ; 0x1034
ffa: 20 32 cpi r18, 0x20 ; 32
ffc: d9 f3 breq .-10 ; 0xff4
ffe: 29 30 cpi r18, 0x09 ; 9
1000: c9 f3 breq .-14 ; 0xff4
1002: 2a 30 cpi r18, 0x0A ; 10
1004: b9 f3 breq .-18 ; 0xff4
1006: 2c 30 cpi r18, 0x0C ; 12
1008: a9 f3 breq .-22 ; 0xff4
100a: 2d 30 cpi r18, 0x0D ; 13
100c: 99 f3 breq .-26 ; 0xff4
100e: 26 37 cpi r18, 0x76 ; 118
1010: 89 f3 breq .-30 ; 0xff4
1012: 2b 32 cpi r18, 0x2B ; 43
1014: 19 f0 breq .+6 ; 0x101c
1016: 2d 32 cpi r18, 0x2D ; 45
1018: 21 f4 brne .+8 ; 0x1022
0000101a <.atoi_neg>:
101a: 68 94 set
0000101c <.atoi_loop2>:
101c: 21 91 ld r18, Z+
101e: 22 23 and r18, r18
1020: 49 f0 breq .+18 ; 0x1034
00001022 <.atoi_digit>:
1022: 20 33 cpi r18, 0x30 ; 48
1024: 3c f0 brlt .+14 ; 0x1034
1026: 2a 33 cpi r18, 0x3A ; 58
1028: 2c f4 brge .+10 ; 0x1034
102a: 20 53 subi r18, 0x30 ; 48
102c: 2f d0 rcall .+94 ; 0x108c
102e: 82 0f add r24, r18
1030: 91 1d adc r25, r1
1032: f4 cf rjmp .-24 ; 0x101c
00001034 <.atoi_sig>:
1034: 81 15 cp r24, r1
1036: 91 05 cpc r25, r1
1038: 21 f0 breq .+8 ; 0x1042
103a: 1e f4 brtc .+6 ; 0x1042
103c: 80 95 com r24
103e: 90 95 com r25
1040: 01 96 adiw r24, 0x01 ; 1
00001042 <.atoi_done>:
1042: 08 95 ret
00001044 <eeprom_read_byte>:
1044: e1 99 sbic 0x1c, 1 ; 28
1046: fe cf rjmp .-4 ; 0x1044
1048: 9f bb out 0x1f, r25 ; 31
104a: 8e bb out 0x1e, r24 ; 30
104c: e0 9a sbi 0x1c, 0 ; 28
104e: 99 27 eor r25, r25
1050: 8d b3 in r24, 0x1d ; 29
1052: 08 95 ret
00001054 <eeprom_read_block>:
1054: 41 15 cp r20, r1
1056: 51 05 cpc r21, r1
1058: 69 f0 breq .+26 ; 0x1074
105a: dc 01 movw r26, r24
0000105c <eeprom_read_block_busy>:
105c: e1 99 sbic 0x1c, 1 ; 28
105e: fe cf rjmp .-4 ; 0x105c
00001060 <eeprom_read_block_loop>:
1060: 7f bb out 0x1f, r23 ; 31
1062: 6e bb out 0x1e, r22 ; 30
1064: e0 9a sbi 0x1c, 0 ; 28
1066: 6f 5f subi r22, 0xFF ; 255
1068: 7f 4f sbci r23, 0xFF ; 255
106a: 0d b2 in r0, 0x1d ; 29
106c: 0d 92 st X+, r0
106e: 41 50 subi r20, 0x01 ; 1
1070: 50 40 sbci r21, 0x00 ; 0
1072: b1 f7 brne .-20 ; 0x1060
00001074 <eeprom_read_block_done>:
1074: 08 95 ret
00001076 <eeprom_write_byte>:
1076: e1 99 sbic 0x1c, 1 ; 28
1078: fe cf rjmp .-4 ; 0x1076
107a: 9f bb out 0x1f, r25 ; 31
107c: 8e bb out 0x1e, r24 ; 30
107e: 6d bb out 0x1d, r22 ; 29
1080: 0f b6 in r0, 0x3f ; 63
1082: f8 94 cli
1084: e2 9a sbi 0x1c, 2 ; 28
1086: e1 9a sbi 0x1c, 1 ; 28
1088: 0f be out 0x3f, r0 ; 63
108a: 08 95 ret
0000108c <__mulhi_const_10>:
108c: 7a e0 ldi r23, 0x0A ; 10
108e: 97 9f mul r25, r23
1090: 90 2d mov r25, r0
1092: 87 9f mul r24, r23
1094: 80 2d mov r24, r0
1096: 91 0d add r25, r1
1098: 11 24 eor r1, r1
109a: 08 95 ret
0000109c <_exit>:
109c: ff cf rjmp .-2 ; 0x109c
1020: 18 95 reti
00001022 <atoi>:
1022: fc 01 movw r30, r24
1024: 88 27 eor r24, r24
1026: 99 27 eor r25, r25
1028: e8 94 clt
102a: 21 91 ld r18, Z+
102c: 22 23 and r18, r18
102e: e9 f0 breq .+58 ; 0x106a <atoi+0x48>
1030: 20 32 cpi r18, 0x20 ; 32
1032: d9 f3 breq .-10 ; 0x102a <atoi+0x8>
1034: 29 30 cpi r18, 0x09 ; 9
1036: c9 f3 breq .-14 ; 0x102a <atoi+0x8>
1038: 2a 30 cpi r18, 0x0A ; 10
103a: b9 f3 breq .-18 ; 0x102a <atoi+0x8>
103c: 2c 30 cpi r18, 0x0C ; 12
103e: a9 f3 breq .-22 ; 0x102a <atoi+0x8>
1040: 2d 30 cpi r18, 0x0D ; 13
1042: 99 f3 breq .-26 ; 0x102a <atoi+0x8>
1044: 26 37 cpi r18, 0x76 ; 118
1046: 89 f3 breq .-30 ; 0x102a <atoi+0x8>
1048: 2b 32 cpi r18, 0x2B ; 43
104a: 19 f0 breq .+6 ; 0x1052 <atoi+0x30>
104c: 2d 32 cpi r18, 0x2D ; 45
104e: 21 f4 brne .+8 ; 0x1058 <atoi+0x36>
1050: 68 94 set
1052: 21 91 ld r18, Z+
1054: 22 23 and r18, r18
1056: 49 f0 breq .+18 ; 0x106a <atoi+0x48>
1058: 20 33 cpi r18, 0x30 ; 48
105a: 3c f0 brlt .+14 ; 0x106a <atoi+0x48>
105c: 2a 33 cpi r18, 0x3A ; 58
105e: 2c f4 brge .+10 ; 0x106a <atoi+0x48>
1060: 20 53 subi r18, 0x30 ; 48
1062: 0b d0 rcall .+22 ; 0x107a <__mulhi_const_10>
1064: 82 0f add r24, r18
1066: 91 1d adc r25, r1
1068: f4 cf rjmp .-24 ; 0x1052 <atoi+0x30>
106a: 81 15 cp r24, r1
106c: 91 05 cpc r25, r1
106e: 21 f0 breq .+8 ; 0x1078 <atoi+0x56>
1070: 1e f4 brtc .+6 ; 0x1078 <atoi+0x56>
1072: 80 95 com r24
1074: 90 95 com r25
1076: 01 96 adiw r24, 0x01 ; 1
1078: 08 95 ret
0000107a <__mulhi_const_10>:
107a: 7a e0 ldi r23, 0x0A ; 10
107c: 97 9f mul r25, r23
107e: 90 2d mov r25, r0
1080: 87 9f mul r24, r23
1082: 80 2d mov r24, r0
1084: 91 0d add r25, r1
1086: 11 24 eor r1, r1
1088: 08 95 ret
0000108a <__eeprom_read_byte_1C1D1E>:
108a: e1 99 sbic 0x1c, 1 ; 28
108c: fe cf rjmp .-4 ; 0x108a <__eeprom_read_byte_1C1D1E>
108e: bf bb out 0x1f, r27 ; 31
1090: ae bb out 0x1e, r26 ; 30
1092: e0 9a sbi 0x1c, 0 ; 28
1094: 11 96 adiw r26, 0x01 ; 1
1096: 0d b2 in r0, 0x1d ; 29
1098: 08 95 ret
0000109a <__eeprom_read_block_1C1D1E>:
109a: f7 df rcall .-18 ; 0x108a <__eeprom_read_byte_1C1D1E>
109c: 01 92 st Z+, r0
109e: 1a 94 dec r1
10a0: e1 f7 brne .-8 ; 0x109a <__eeprom_read_block_1C1D1E>
10a2: 08 95 ret
000010a4 <__eeprom_write_byte_1C1D1E>:
10a4: e1 99 sbic 0x1c, 1 ; 28
10a6: fe cf rjmp .-4 ; 0x10a4 <__eeprom_write_byte_1C1D1E>
10a8: bf bb out 0x1f, r27 ; 31
10aa: ae bb out 0x1e, r26 ; 30
10ac: 0d ba out 0x1d, r0 ; 29
10ae: 11 96 adiw r26, 0x01 ; 1
10b0: 0f b6 in r0, 0x3f ; 63
10b2: f8 94 cli
10b4: e2 9a sbi 0x1c, 2 ; 28
10b6: e1 9a sbi 0x1c, 1 ; 28
10b8: 0f be out 0x3f, r0 ; 63
10ba: 08 95 ret
000010bc <_exit>:
10bc: ff cf rjmp .-2 ; 0x10bc <_exit>