| 151 |
kaklik |
1 |
|
|
|
2 |
AVRcam.elf: file format elf32-avr
|
|
|
3 |
|
|
|
4 |
Sections:
|
|
|
5 |
Idx Name Size VMA LMA File off Algn
|
|
|
6 |
|
|
|
7 |
ALLOC
|
|
|
8 |
1 .bss 00000274 00800070 00800070 00001162 2**0
|
|
|
9 |
ALLOC
|
|
|
10 |
2 .data 00000010 00800060 0000109e 00001152 2**0
|
|
|
11 |
CONTENTS, ALLOC, LOAD, DATA
|
|
|
12 |
3 .text 0000109e 00000000 00000000 000000b4 2**1
|
|
|
13 |
CONTENTS, ALLOC, LOAD, READONLY, CODE
|
|
|
14 |
4 .eeprom 00000000 00810000 00810000 00001162 2**0
|
|
|
15 |
CONTENTS
|
|
|
16 |
5 .stab 00003f30 00000000 00000000 00001164 2**2
|
|
|
17 |
CONTENTS, READONLY, DEBUGGING
|
|
|
18 |
6 .stabstr 0000181e 00000000 00000000 00005094 2**0
|
|
|
19 |
CONTENTS, READONLY, DEBUGGING
|
|
|
20 |
Disassembly of section .text:
|
|
|
21 |
|
|
|
22 |
00000000 <__vectors>:
|
|
|
23 |
0: 63 c0 rjmp .+198 ; 0xc8
|
|
|
24 |
2: ea c7 rjmp .+4052 ; 0xfd8
|
|
|
25 |
4: ea c7 rjmp .+4052 ; 0xfda
|
|
|
26 |
6: 7a c0 rjmp .+244 ; 0xfc
|
|
|
27 |
8: 79 c0 rjmp .+242 ; 0xfc
|
|
|
28 |
a: 78 c0 rjmp .+240 ; 0xfc
|
|
|
29 |
c: 77 c0 rjmp .+238 ; 0xfc
|
|
|
30 |
e: 76 c0 rjmp .+236 ; 0xfc
|
|
|
31 |
10: e5 c7 rjmp .+4042 ; 0xfdc
|
|
|
32 |
12: 74 c0 rjmp .+232 ; 0xfc
|
|
|
33 |
14: 73 c0 rjmp .+230 ; 0xfc
|
|
|
34 |
16: a8 c5 rjmp .+2896 ; 0xb68
|
|
|
35 |
18: 71 c0 rjmp .+226 ; 0xfc
|
|
|
36 |
1a: 70 c0 rjmp .+224 ; 0xfc
|
|
|
37 |
1c: 6f c0 rjmp .+222 ; 0xfc
|
|
|
38 |
1e: 6e c0 rjmp .+220 ; 0xfc
|
|
|
39 |
20: 6d c0 rjmp .+218 ; 0xfc
|
|
|
40 |
22: 13 c6 rjmp .+3110 ; 0xc4a
|
|
|
41 |
24: 6b c0 rjmp .+214 ; 0xfc
|
|
|
42 |
|
|
|
43 |
00000026 <__ctors_end>:
|
|
|
44 |
26: 2a c6 rjmp .+3156 ; 0xc7c
|
|
|
45 |
28: 93 c6 rjmp .+3366 ; 0xd50
|
|
|
46 |
2a: 92 c6 rjmp .+3364 ; 0xd50
|
|
|
47 |
2c: 91 c6 rjmp .+3362 ; 0xd50
|
|
|
48 |
2e: 90 c6 rjmp .+3360 ; 0xd50
|
|
|
49 |
30: 8f c6 rjmp .+3358 ; 0xd50
|
|
|
50 |
32: 8e c6 rjmp .+3356 ; 0xd50
|
|
|
51 |
34: 8d c6 rjmp .+3354 ; 0xd50
|
|
|
52 |
36: 22 c6 rjmp .+3140 ; 0xc7c
|
|
|
53 |
38: 8b c6 rjmp .+3350 ; 0xd50
|
|
|
54 |
3a: 8a c6 rjmp .+3348 ; 0xd50
|
|
|
55 |
3c: 89 c6 rjmp .+3346 ; 0xd50
|
|
|
56 |
3e: 88 c6 rjmp .+3344 ; 0xd50
|
|
|
57 |
40: 87 c6 rjmp .+3342 ; 0xd50
|
|
|
58 |
42: 86 c6 rjmp .+3340 ; 0xd50
|
|
|
59 |
44: 85 c6 rjmp .+3338 ; 0xd50
|
|
|
60 |
46: 2a c6 rjmp .+3156 ; 0xc9c
|
|
|
61 |
48: 83 c6 rjmp .+3334 ; 0xd50
|
|
|
62 |
4a: 82 c6 rjmp .+3332 ; 0xd50
|
|
|
63 |
4c: 81 c6 rjmp .+3330 ; 0xd50
|
|
|
64 |
4e: 80 c6 rjmp .+3328 ; 0xd50
|
|
|
65 |
50: 7f c6 rjmp .+3326 ; 0xd50
|
|
|
66 |
52: 7e c6 rjmp .+3324 ; 0xd50
|
|
|
67 |
54: 7d c6 rjmp .+3322 ; 0xd50
|
|
|
68 |
56: 25 c6 rjmp .+3146 ; 0xca2
|
|
|
69 |
58: 7b c6 rjmp .+3318 ; 0xd50
|
|
|
70 |
5a: 7a c6 rjmp .+3316 ; 0xd50
|
|
|
71 |
5c: 79 c6 rjmp .+3314 ; 0xd50
|
|
|
72 |
5e: 78 c6 rjmp .+3312 ; 0xd50
|
|
|
73 |
60: 77 c6 rjmp .+3310 ; 0xd50
|
|
|
74 |
62: 76 c6 rjmp .+3308 ; 0xd50
|
|
|
75 |
64: 75 c6 rjmp .+3306 ; 0xd50
|
|
|
76 |
66: 25 c6 rjmp .+3146 ; 0xcb2
|
|
|
77 |
68: 73 c6 rjmp .+3302 ; 0xd50
|
|
|
78 |
6a: 72 c6 rjmp .+3300 ; 0xd50
|
|
|
79 |
6c: 71 c6 rjmp .+3298 ; 0xd50
|
|
|
80 |
6e: 70 c6 rjmp .+3296 ; 0xd50
|
|
|
81 |
70: 6f c6 rjmp .+3294 ; 0xd50
|
|
|
82 |
72: 6e c6 rjmp .+3292 ; 0xd50
|
|
|
83 |
74: 6d c6 rjmp .+3290 ; 0xd50
|
|
|
84 |
76: 64 c6 rjmp .+3272 ; 0xd40
|
|
|
85 |
78: 6b c6 rjmp .+3286 ; 0xd50
|
|
|
86 |
7a: 6a c6 rjmp .+3284 ; 0xd50
|
|
|
87 |
7c: 69 c6 rjmp .+3282 ; 0xd50
|
|
|
88 |
7e: 68 c6 rjmp .+3280 ; 0xd50
|
|
|
89 |
80: 67 c6 rjmp .+3278 ; 0xd50
|
|
|
90 |
82: 66 c6 rjmp .+3276 ; 0xd50
|
|
|
91 |
84: 65 c6 rjmp .+3274 ; 0xd50
|
|
|
92 |
86: 64 c6 rjmp .+3272 ; 0xd50
|
|
|
93 |
88: 63 c6 rjmp .+3270 ; 0xd50
|
|
|
94 |
8a: 62 c6 rjmp .+3268 ; 0xd50
|
|
|
95 |
8c: 61 c6 rjmp .+3266 ; 0xd50
|
|
|
96 |
8e: 60 c6 rjmp .+3264 ; 0xd50
|
|
|
97 |
90: 5f c6 rjmp .+3262 ; 0xd50
|
|
|
98 |
92: 5e c6 rjmp .+3260 ; 0xd50
|
|
|
99 |
94: 5d c6 rjmp .+3258 ; 0xd50
|
|
|
100 |
96: 23 c6 rjmp .+3142 ; 0xcde
|
|
|
101 |
98: 5b c6 rjmp .+3254 ; 0xd50
|
|
|
102 |
9a: 5a c6 rjmp .+3252 ; 0xd50
|
|
|
103 |
9c: 59 c6 rjmp .+3250 ; 0xd50
|
|
|
104 |
9e: 58 c6 rjmp .+3248 ; 0xd50
|
|
|
105 |
a0: 57 c6 rjmp .+3246 ; 0xd50
|
|
|
106 |
a2: 56 c6 rjmp .+3244 ; 0xd50
|
|
|
107 |
a4: 55 c6 rjmp .+3242 ; 0xd50
|
|
|
108 |
a6: fd c5 rjmp .+3066 ; 0xca2
|
|
|
109 |
a8: 53 c6 rjmp .+3238 ; 0xd50
|
|
|
110 |
aa: 52 c6 rjmp .+3236 ; 0xd50
|
|
|
111 |
ac: 51 c6 rjmp .+3234 ; 0xd50
|
|
|
112 |
ae: 50 c6 rjmp .+3232 ; 0xd50
|
|
|
113 |
b0: 4f c6 rjmp .+3230 ; 0xd50
|
|
|
114 |
b2: 4e c6 rjmp .+3228 ; 0xd50
|
|
|
115 |
b4: 4d c6 rjmp .+3226 ; 0xd50
|
|
|
116 |
b6: 1f c6 rjmp .+3134 ; 0xcf6
|
|
|
117 |
b8: 4b c6 rjmp .+3222 ; 0xd50
|
|
|
118 |
ba: 4a c6 rjmp .+3220 ; 0xd50
|
|
|
119 |
bc: 49 c6 rjmp .+3218 ; 0xd50
|
|
|
120 |
be: 48 c6 rjmp .+3216 ; 0xd50
|
|
|
121 |
c0: 47 c6 rjmp .+3214 ; 0xd50
|
|
|
122 |
c2: 46 c6 rjmp .+3212 ; 0xd50
|
|
|
123 |
c4: 45 c6 rjmp .+3210 ; 0xd50
|
|
|
124 |
c6: 36 c6 rjmp .+3180 ; 0xd34
|
|
|
125 |
|
|
|
126 |
000000c8 <__init>:
|
|
|
127 |
c8: 11 24 eor r1, r1
|
|
|
128 |
ca: 1f be out 0x3f, r1 ; 63
|
|
|
129 |
cc: cf e5 ldi r28, 0x5F ; 95
|
|
|
130 |
ce: d4 e0 ldi r29, 0x04 ; 4
|
|
|
131 |
d0: de bf out 0x3e, r29 ; 62
|
|
|
132 |
d2: cd bf out 0x3d, r28 ; 61
|
|
|
133 |
|
|
|
134 |
000000d4 <__do_copy_data>:
|
|
|
135 |
d4: 10 e0 ldi r17, 0x00 ; 0
|
|
|
136 |
d6: a0 e6 ldi r26, 0x60 ; 96
|
|
|
137 |
d8: b0 e0 ldi r27, 0x00 ; 0
|
|
|
138 |
da: ee e9 ldi r30, 0x9E ; 158
|
|
|
139 |
dc: f0 e1 ldi r31, 0x10 ; 16
|
|
|
140 |
de: 02 c0 rjmp .+4 ; 0xe4
|
|
|
141 |
|
|
|
142 |
000000e0 <.do_copy_data_loop>:
|
|
|
143 |
e0: 05 90 lpm r0, Z+
|
|
|
144 |
e2: 0d 92 st X+, r0
|
|
|
145 |
|
|
|
146 |
000000e4 <.do_copy_data_start>:
|
|
|
147 |
e4: a0 37 cpi r26, 0x70 ; 112
|
|
|
148 |
e6: b1 07 cpc r27, r17
|
|
|
149 |
e8: d9 f7 brne .-10 ; 0xe0
|
|
|
150 |
|
|
|
151 |
000000ea <__do_clear_bss>:
|
|
|
152 |
ea: 12 e0 ldi r17, 0x02 ; 2
|
|
|
153 |
ec: a0 e7 ldi r26, 0x70 ; 112
|
|
|
154 |
ee: b0 e0 ldi r27, 0x00 ; 0
|
|
|
155 |
f0: 01 c0 rjmp .+2 ; 0xf4
|
|
|
156 |
|
|
|
157 |
000000f2 <.do_clear_bss_loop>:
|
|
|
158 |
f2: 1d 92 st X+, r1
|
|
|
159 |
|
|
|
160 |
000000f4 <.do_clear_bss_start>:
|
|
|
161 |
f4: a4 3e cpi r26, 0xE4 ; 228
|
|
|
162 |
f6: b1 07 cpc r27, r17
|
|
|
163 |
f8: e1 f7 brne .-8 ; 0xf2
|
|
|
164 |
fa: 31 c0 rjmp .+98 ; 0x15e
|
|
|
165 |
|
|
|
166 |
000000fc <__bad_interrupt>:
|
|
|
167 |
fc: 76 c7 rjmp .+3820 ; 0xfea
|
|
|
168 |
|
|
|
169 |
000000fe <CamInt_init>:
|
|
|
170 |
#endif
|
|
|
171 |
|
|
|
172 |
/* set up the mega8 ports that will be interfacing
|
|
|
173 |
with the camera */
|
|
|
174 |
CAM_CONTROL_PORT_DIR |= (1<<CAM_RESET_LINE); /* cam reset is output */
|
|
|
175 |
fe: 8f 9a sbi 0x11, 7 ; 17
|
|
|
176 |
CAM_CONTROL_PORT_DIR |= 0x80; /* set just the MSB as an output */
|
|
|
177 |
100: 8f 9a sbi 0x11, 7 ; 17
|
|
|
178 |
CAM_CONTROL_PORT_DIR &= 0xFB; /* make sure bit2 is clear (input) */
|
|
|
179 |
102: 8a 98 cbi 0x11, 2 ; 17
|
|
|
180 |
CAM_CONTROL_PORT &= 0x7F; /* set reset line low */
|
|
|
181 |
104: 97 98 cbi 0x12, 7 ; 18
|
|
|
182 |
CAM_G_BUS_DIR &= 0xF0; /* 4-bit G bus all inputs */
|
|
|
183 |
106: 90 ef ldi r25, 0xF0 ; 240
|
|
|
184 |
108: 87 b3 in r24, 0x17 ; 23
|
|
|
185 |
10a: 89 23 and r24, r25
|
|
|
186 |
10c: 87 bb out 0x17, r24 ; 23
|
|
|
187 |
CAM_G_BUS_DIR |= 0xF0; /* disable the pull-up on PB4 and PB5 */
|
|
|
188 |
10e: 87 b3 in r24, 0x17 ; 23
|
|
|
189 |
110: 89 2b or r24, r25
|
|
|
190 |
112: 87 bb out 0x17, r24 ; 23
|
|
|
191 |
CAM_RB_BUS_DIR &= 0xF0; /* 4-bit RB bus all inputs */
|
|
|
192 |
114: 84 b3 in r24, 0x14 ; 20
|
|
|
193 |
116: 89 23 and r24, r25
|
|
|
194 |
118: 84 bb out 0x14, r24 ; 20
|
|
|
195 |
|
|
|
196 |
/* ensure that timer1 is disabled to start...eventually, when PCLK needs
|
|
|
197 |
to feed timer1 through the external counter, it will be enabled on an
|
|
|
198 |
"as needed" basis...*/
|
|
|
199 |
TCCR1B &= ~( (1<<CS12)|(1<<CS11)|(1<<CS10) );
|
|
|
200 |
11a: 8e b5 in r24, 0x2e ; 46
|
|
|
201 |
11c: 88 7f andi r24, 0xF8 ; 248
|
|
|
202 |
11e: 8e bd out 0x2e, r24 ; 46
|
|
|
203 |
|
|
|
204 |
/* we'll turn on the interrupt after we assign the initial TCNT value */
|
|
|
205 |
|
|
|
206 |
/* set up External Interrupt1 to interrupt us on rising edges (HREF)...
|
|
|
207 |
this is needed to indicate when the first pixel of each line is about to start, so
|
|
|
208 |
we can synch up with it...this interrupt will be disabled once HREF goes high */
|
|
|
209 |
|
|
|
210 |
MCUCR |= (1<<ISC11) | (1<<ISC10); /* rising edge interrupt */
|
|
|
211 |
120: 85 b7 in r24, 0x35 ; 53
|
|
|
212 |
122: 8c 60 ori r24, 0x0C ; 12
|
|
|
213 |
124: 85 bf out 0x35, r24 ; 53
|
|
|
214 |
/* the interrupt will be enabled when we are ready to detect the rising edge of
|
|
|
215 |
HREF...its now primed and ready to go */
|
|
|
216 |
|
|
|
217 |
/* set up External Interrupt0 to interrupt us on rising edges (VSYNC) */
|
|
|
218 |
MCUCR |= (1<<ISC01) | (1<<ISC00); /* rising edge interrupt */
|
|
|
219 |
126: 85 b7 in r24, 0x35 ; 53
|
|
|
220 |
128: 83 60 ori r24, 0x03 ; 3
|
|
|
221 |
12a: 85 bf out 0x35, r24 ; 53
|
|
|
222 |
GICR |= (1<<INT0); /* interrupt request enabled */
|
|
|
223 |
12c: 8b b7 in r24, 0x3b ; 59
|
|
|
224 |
12e: 80 64 ori r24, 0x40 ; 64
|
|
|
225 |
130: 8b bf out 0x3b, r24 ; 59
|
|
|
226 |
|
|
|
227 |
/* set up TimerO to count and be clocked from an external pulse source
|
|
|
228 |
(HREF) on falling edges...eventually, we need to enable the interrupt
|
|
|
229 |
for this! FIX THIS */
|
|
|
230 |
TCCR0 = (1<<CS02)|(1<<CS01)|(0<<CS00);
|
|
|
231 |
132: 86 e0 ldi r24, 0x06 ; 6
|
|
|
232 |
134: 83 bf out 0x33, r24 ; 51
|
|
|
233 |
|
|
|
234 |
/* setting up the PCLK counter with Timer1 will be done right after
|
|
|
235 |
we start receiving pixels in each line...we sacrifice the first pixel
|
|
|
236 |
in each line, but we'll account for it...*/
|
|
|
237 |
|
|
|
238 |
/* set up the mega8 so that its sleep mode puts it in an IDLE sleep
|
|
|
239 |
mode, where it can wake up as fast as possible */
|
|
|
240 |
set_sleep_mode(SLEEP_MODE_IDLE);
|
|
|
241 |
136: 85 b7 in r24, 0x35 ; 53
|
|
|
242 |
138: 8f 78 andi r24, 0x8F ; 143
|
|
|
243 |
13a: 85 bf out 0x35, r24 ; 53
|
|
|
244 |
/* umm....we need to actually enable the sleep mode...*/
|
|
|
245 |
MCUCR |= 0x80;
|
|
|
246 |
13c: 85 b7 in r24, 0x35 ; 53
|
|
|
247 |
13e: 80 68 ori r24, 0x80 ; 128
|
|
|
248 |
140: 85 bf out 0x35, r24 ; 53
|
|
|
249 |
|
|
|
250 |
/* initialize the memLookup table */
|
|
|
251 |
memset(colorMap,0x00,NUM_ELEMENTS_IN_COLOR_MAP);
|
|
|
252 |
142: 80 e0 ldi r24, 0x00 ; 0
|
|
|
253 |
144: 93 e0 ldi r25, 0x03 ; 3
|
|
|
254 |
146: 20 e3 ldi r18, 0x30 ; 48
|
|
|
255 |
148: fc 01 movw r30, r24
|
|
|
256 |
14a: 11 92 st Z+, r1
|
|
|
257 |
14c: 2a 95 dec r18
|
|
|
258 |
14e: e9 f7 brne .-6 ; 0x14a
|
|
|
259 |
|
|
|
260 |
/* read the color map out of EEPROM */
|
|
|
261 |
eeprom_read_block(colorMap, (unsigned char*)0x01,NUM_ELEMENTS_IN_COLOR_MAP);
|
|
|
262 |
150: 40 e3 ldi r20, 0x30 ; 48
|
|
|
263 |
152: 50 e0 ldi r21, 0x00 ; 0
|
|
|
264 |
154: 61 e0 ldi r22, 0x01 ; 1
|
|
|
265 |
156: 70 e0 ldi r23, 0x00 ; 0
|
|
|
266 |
158: 7d d7 rcall .+3834 ; 0x1054
|
|
|
267 |
|
|
|
268 |
#if OUTPUT_INITIAL_COLOR_MAP
|
|
|
269 |
UIMgr_txBuffer("\r\n",2);
|
|
|
270 |
for (i=0; i<NUM_ELEMENTS_IN_COLOR_MAP; i++)
|
|
|
271 |
{
|
|
|
272 |
memset(asciiBuffer,0x00,5);
|
|
|
273 |
itoa(colorMap[i],asciiBuffer,10);
|
|
|
274 |
UIMgr_txBuffer(asciiBuffer,3);
|
|
|
275 |
UIMgr_txBuffer(" ",1);
|
|
|
276 |
if (i==15 || i == 31)
|
|
|
277 |
{
|
|
|
278 |
/* break up the output */
|
|
|
279 |
UIMgr_txBuffer("\r\n",2);
|
|
|
280 |
}
|
|
|
281 |
}
|
|
|
282 |
#endif
|
|
|
283 |
|
|
|
284 |
#ifndef NO_CRYSTAL
|
|
|
285 |
CamInt_resetCam();
|
|
|
286 |
#endif
|
|
|
287 |
}
|
|
|
288 |
15a: 08 95 ret
|
|
|
289 |
|
|
|
290 |
0000015c <CamInt_resetCam>:
|
|
|
291 |
|
|
|
292 |
/***********************************************************
|
|
|
293 |
Function Name: CamInt_resetCam
|
|
|
294 |
Function Description: This function is responsible
|
|
|
295 |
for resetting the camera. This is accomplished by
|
|
|
296 |
toggling the reset line on the OV6620 for ~100 mS.
|
|
|
297 |
Inputs: none
|
|
|
298 |
Outputs: none
|
|
|
299 |
IMPORTANT NOTE: This function has effectively been removed
|
|
|
300 |
since resetting the camera now causes the camera to not
|
|
|
301 |
output the clock signal. Thus, if we reset the cam, the
|
|
|
302 |
AVR has no clock, and thus doesn't run...
|
|
|
303 |
***********************************************************/
|
|
|
304 |
void CamInt_resetCam(void)
|
|
|
305 |
{
|
|
|
306 |
15c: 08 95 ret
|
|
|
307 |
|
|
|
308 |
0000015e <main>:
|
|
|
309 |
Inputs: none
|
|
|
310 |
Outputs: int
|
|
|
311 |
***********************************************************/
|
|
|
312 |
int main(void)
|
|
|
313 |
{
|
|
|
314 |
15e: cf e5 ldi r28, 0x5F ; 95
|
|
|
315 |
160: d4 e0 ldi r29, 0x04 ; 4
|
|
|
316 |
162: de bf out 0x3e, r29 ; 62
|
|
|
317 |
164: cd bf out 0x3d, r28 ; 61
|
|
|
318 |
/* initialize all of the interface modules */
|
|
|
319 |
DebugInt_init();
|
|
|
320 |
166: aa d6 rcall .+3412 ; 0xebc
|
|
|
321 |
UartInt_init();
|
|
|
322 |
168: f1 d4 rcall .+2530 ; 0xb4c
|
|
|
323 |
I2CInt_init();
|
|
|
324 |
16a: 2c d5 rcall .+2648 ; 0xbc4
|
|
|
325 |
CamInt_init();
|
|
|
326 |
16c: c8 df rcall .-112 ; 0xfe
|
|
|
327 |
|
|
|
328 |
/* initialize the remaining modules that will process
|
|
|
329 |
data...interrupts need to be on for these */
|
|
|
330 |
ENABLE_INTS();
|
|
|
331 |
16e: 78 94 sei
|
|
|
332 |
CamConfig_init();
|
|
|
333 |
170: fa d5 rcall .+3060 ; 0xd66
|
|
|
334 |
UIMgr_init();
|
|
|
335 |
172: 94 d2 rcall .+1320 ; 0x69c
|
|
|
336 |
FrameMgr_init();
|
|
|
337 |
174: 7f d0 rcall .+254 ; 0x274
|
|
|
338 |
|
|
|
339 |
/* provide a short delay for the camera to stabilize before
|
|
|
340 |
we let the executive start up */
|
|
|
341 |
Utility_delay(1000);
|
|
|
342 |
176: 88 ee ldi r24, 0xE8 ; 232
|
|
|
343 |
178: 93 e0 ldi r25, 0x03 ; 3
|
|
|
344 |
17a: 65 d6 rcall .+3274 ; 0xe46
|
|
|
345 |
|
|
|
346 |
/* the rest of the application will be under the
|
|
|
347 |
control of the Executive. */
|
|
|
348 |
Exec_run();
|
|
|
349 |
17c: 03 d0 rcall .+6 ; 0x184
|
|
|
350 |
|
|
|
351 |
/* this should never be reached */
|
|
|
352 |
return(0);
|
|
|
353 |
}
|
|
|
354 |
17e: 80 e0 ldi r24, 0x00 ; 0
|
|
|
355 |
180: 90 e0 ldi r25, 0x00 ; 0
|
|
|
356 |
182: 8c c7 rjmp .+3864 ; 0x109c
|
|
|
357 |
|
|
|
358 |
00000184 <Exec_run>:
|
|
|
359 |
Inputs: none
|
|
|
360 |
Outputs: none
|
|
|
361 |
***********************************************************/
|
|
|
362 |
void Exec_run(void)
|
|
|
363 |
{
|
|
|
364 |
184: cf 93 push r28
|
|
|
365 |
unsigned char eventGenerated;
|
|
|
366 |
|
|
|
367 |
while(1)
|
|
|
368 |
{
|
|
|
369 |
if (fastEventBitmask)
|
|
|
370 |
186: 80 91 72 00 lds r24, 0x0072
|
|
|
371 |
18a: 88 23 and r24, r24
|
|
|
372 |
18c: b9 f0 breq .+46 ; 0x1bc
|
|
|
373 |
{
|
|
|
374 |
/* an event needing fast processing has been received */
|
|
|
375 |
/* a received line needs to be processed...this
|
|
|
376 |
needs to be processed as quickly as possible */
|
|
|
377 |
if (fastEventBitmask & FEV_ACQUIRE_LINE_COMPLETE)
|
|
|
378 |
18e: 80 ff sbrs r24, 0
|
|
|
379 |
190: 09 c0 rjmp .+18 ; 0x1a4
|
|
|
380 |
{
|
|
|
381 |
DISABLE_INTS();
|
|
|
382 |
192: f8 94 cli
|
|
|
383 |
fastEventBitmask &= ~FEV_ACQUIRE_LINE_COMPLETE;
|
|
|
384 |
194: 80 91 72 00 lds r24, 0x0072
|
|
|
385 |
198: 8e 7f andi r24, 0xFE ; 254
|
|
|
386 |
19a: 80 93 72 00 sts 0x0072, r24
|
|
|
387 |
ENABLE_INTS();
|
|
|
388 |
19e: 78 94 sei
|
|
|
389 |
FrameMgr_processLine();
|
|
|
390 |
1a0: f8 d0 rcall .+496 ; 0x392
|
|
|
391 |
|
|
|
392 |
/* also check if serial data needs to be sent
|
|
|
393 |
out through UIMgr */
|
|
|
394 |
UIMgr_transmitPendingData();
|
|
|
395 |
1a2: ac d2 rcall .+1368 ; 0x6fc
|
|
|
396 |
|
|
|
397 |
/* we can't just call acquire line again here,
|
|
|
398 |
since we don't know if we need to acquire another
|
|
|
399 |
line or not (it depends on the FrameMgr to figure
|
|
|
400 |
this out) */
|
|
|
401 |
}
|
|
|
402 |
if (fastEventBitmask & FEV_PROCESS_LINE_COMPLETE)
|
|
|
403 |
1a4: 80 91 72 00 lds r24, 0x0072
|
|
|
404 |
1a8: 81 ff sbrs r24, 1
|
|
|
405 |
1aa: 08 c0 rjmp .+16 ; 0x1bc
|
|
|
406 |
{
|
|
|
407 |
DISABLE_INTS();
|
|
|
408 |
1ac: f8 94 cli
|
|
|
409 |
fastEventBitmask &= ~FEV_PROCESS_LINE_COMPLETE;
|
|
|
410 |
1ae: 80 91 72 00 lds r24, 0x0072
|
|
|
411 |
1b2: 8d 7f andi r24, 0xFD ; 253
|
|
|
412 |
1b4: 80 93 72 00 sts 0x0072, r24
|
|
|
413 |
ENABLE_INTS();
|
|
|
414 |
1b8: 78 94 sei
|
|
|
415 |
FrameMgr_acquireLine();
|
|
|
416 |
1ba: b9 d0 rcall .+370 ; 0x32e
|
|
|
417 |
}
|
|
|
418 |
}
|
|
|
419 |
|
|
|
420 |
if (IS_DATA_IN_EVENT_FIFO() == TRUE)
|
|
|
421 |
1bc: 90 91 70 00 lds r25, 0x0070
|
|
|
422 |
1c0: 80 91 71 00 lds r24, 0x0071
|
|
|
423 |
1c4: 98 17 cp r25, r24
|
|
|
424 |
1c6: f9 f2 breq .-66 ; 0x186
|
|
|
425 |
{
|
|
|
426 |
eventGenerated = Exec_readEventFifo();
|
|
|
427 |
1c8: 32 d0 rcall .+100 ; 0x22e
|
|
|
428 |
1ca: c8 2f mov r28, r24
|
|
|
429 |
switch(eventGenerated)
|
|
|
430 |
1cc: 99 27 eor r25, r25
|
|
|
431 |
1ce: 80 31 cpi r24, 0x10 ; 16
|
|
|
432 |
1d0: 91 05 cpc r25, r1
|
|
|
433 |
1d2: 11 f1 breq .+68 ; 0x218
|
|
|
434 |
1d4: 81 31 cpi r24, 0x11 ; 17
|
|
|
435 |
1d6: 91 05 cpc r25, r1
|
|
|
436 |
1d8: 7c f4 brge .+30 ; 0x1f8
|
|
|
437 |
1da: 82 30 cpi r24, 0x02 ; 2
|
|
|
438 |
1dc: 91 05 cpc r25, r1
|
|
|
439 |
1de: 09 f1 breq .+66 ; 0x222
|
|
|
440 |
1e0: 83 30 cpi r24, 0x03 ; 3
|
|
|
441 |
1e2: 91 05 cpc r25, r1
|
|
|
442 |
1e4: 1c f4 brge .+6 ; 0x1ec
|
|
|
443 |
1e6: 01 97 sbiw r24, 0x01 ; 1
|
|
|
444 |
1e8: d1 f0 breq .+52 ; 0x21e
|
|
|
445 |
1ea: cd cf rjmp .-102 ; 0x186
|
|
|
446 |
1ec: 84 30 cpi r24, 0x04 ; 4
|
|
|
447 |
1ee: 91 05 cpc r25, r1
|
|
|
448 |
1f0: c1 f0 breq .+48 ; 0x222
|
|
|
449 |
1f2: 08 97 sbiw r24, 0x08 ; 8
|
|
|
450 |
1f4: b1 f0 breq .+44 ; 0x222
|
|
|
451 |
1f6: c7 cf rjmp .-114 ; 0x186
|
|
|
452 |
1f8: 80 38 cpi r24, 0x80 ; 128
|
|
|
453 |
1fa: 91 05 cpc r25, r1
|
|
|
454 |
1fc: 91 f0 breq .+36 ; 0x222
|
|
|
455 |
1fe: 81 38 cpi r24, 0x81 ; 129
|
|
|
456 |
200: 91 05 cpc r25, r1
|
|
|
457 |
202: 1c f4 brge .+6 ; 0x20a
|
|
|
458 |
204: 80 97 sbiw r24, 0x20 ; 32
|
|
|
459 |
206: 69 f0 breq .+26 ; 0x222
|
|
|
460 |
208: be cf rjmp .-132 ; 0x186
|
|
|
461 |
20a: 81 38 cpi r24, 0x81 ; 129
|
|
|
462 |
20c: 91 05 cpc r25, r1
|
|
|
463 |
20e: 49 f0 breq .+18 ; 0x222
|
|
|
464 |
210: 80 39 cpi r24, 0x90 ; 144
|
|
|
465 |
212: 91 05 cpc r25, r1
|
|
|
466 |
214: 49 f0 breq .+18 ; 0x228
|
|
|
467 |
216: b7 cf rjmp .-146 ; 0x186
|
|
|
468 |
{
|
|
|
469 |
case (EV_DUMP_FRAME):
|
|
|
470 |
FrameMgr_dispatchEvent(eventGenerated);
|
|
|
471 |
break;
|
|
|
472 |
|
|
|
473 |
case (EV_ENABLE_TRACKING):
|
|
|
474 |
FrameMgr_dispatchEvent(eventGenerated);
|
|
|
475 |
break;
|
|
|
476 |
|
|
|
477 |
case (EV_DISABLE_TRACKING):
|
|
|
478 |
FrameMgr_dispatchEvent(eventGenerated);
|
|
|
479 |
break;
|
|
|
480 |
|
|
|
481 |
case (EV_ACQUIRE_LINE_COMPLETE):
|
|
|
482 |
FrameMgr_dispatchEvent(eventGenerated);
|
|
|
483 |
218: 8c 2f mov r24, r28
|
|
|
484 |
21a: 33 d0 rcall .+102 ; 0x282
|
|
|
485 |
UIMgr_dispatchEvent(eventGenerated);
|
|
|
486 |
21c: 05 c0 rjmp .+10 ; 0x228
|
|
|
487 |
break;
|
|
|
488 |
|
|
|
489 |
case (EV_ACQUIRE_FRAME_COMPLETE):
|
|
|
490 |
FrameMgr_dispatchEvent(eventGenerated);
|
|
|
491 |
break;
|
|
|
492 |
|
|
|
493 |
case (EV_PROCESS_LINE_COMPLETE):
|
|
|
494 |
FrameMgr_dispatchEvent(eventGenerated);
|
|
|
495 |
break;
|
|
|
496 |
|
|
|
497 |
case (EV_PROCESS_FRAME_COMPLETE):
|
|
|
498 |
FrameMgr_dispatchEvent(eventGenerated);
|
|
|
499 |
break;
|
|
|
500 |
|
|
|
501 |
case (EV_SERIAL_DATA_RECEIVED):
|
|
|
502 |
UIMgr_dispatchEvent(eventGenerated);
|
|
|
503 |
21e: 8c 2f mov r24, r28
|
|
|
504 |
220: 58 d2 rcall .+1200 ; 0x6d2
|
|
|
505 |
FrameMgr_dispatchEvent(eventGenerated);
|
|
|
506 |
222: 8c 2f mov r24, r28
|
|
|
507 |
224: 2e d0 rcall .+92 ; 0x282
|
|
|
508 |
break;
|
|
|
509 |
226: af cf rjmp .-162 ; 0x186
|
|
|
510 |
|
|
|
511 |
case (EV_SERIAL_DATA_PENDING_TX):
|
|
|
512 |
UIMgr_dispatchEvent(eventGenerated);
|
|
|
513 |
228: 8c 2f mov r24, r28
|
|
|
514 |
22a: 53 d2 rcall .+1190 ; 0x6d2
|
|
|
515 |
break;
|
|
|
516 |
22c: ac cf rjmp .-168 ; 0x186
|
|
|
517 |
|
|
|
518 |
0000022e <Exec_readEventFifo>:
|
|
|
519 |
|
|
|
520 |
default:
|
|
|
521 |
break;
|
|
|
522 |
}
|
|
|
523 |
}
|
|
|
524 |
|
|
|
525 |
/* toggle the debug line */
|
|
|
526 |
|
|
|
527 |
}
|
|
|
528 |
}
|
|
|
529 |
|
|
|
530 |
/***********************************************************
|
|
|
531 |
Function Name: Exec_readEventFifo
|
|
|
532 |
Function Description: This function is responsible for
|
|
|
533 |
reading a single event out of the event fifo.
|
|
|
534 |
Inputs: none
|
|
|
535 |
Outputs: unsigned char-the data read
|
|
|
536 |
***********************************************************/
|
|
|
537 |
static unsigned char Exec_readEventFifo(void)
|
|
|
538 |
{
|
|
|
539 |
unsigned char dataByte, tmpTail;
|
|
|
540 |
|
|
|
541 |
DISABLE_INTS();
|
|
|
542 |
22e: f8 94 cli
|
|
|
543 |
/* just return the current tail from the tx fifo */
|
|
|
544 |
dataByte = Exec_eventFifo[Exec_eventFifoTail];
|
|
|
545 |
230: 20 91 71 00 lds r18, 0x0071
|
|
|
546 |
234: 8c e6 ldi r24, 0x6C ; 108
|
|
|
547 |
236: 92 e0 ldi r25, 0x02 ; 2
|
|
|
548 |
238: fc 01 movw r30, r24
|
|
|
549 |
23a: e2 0f add r30, r18
|
|
|
550 |
23c: f1 1d adc r31, r1
|
|
|
551 |
23e: 90 81 ld r25, Z
|
|
|
552 |
tmpTail = (Exec_eventFifoTail+1) & (EXEC_EVENT_FIFO_MASK);
|
|
|
553 |
240: 82 2f mov r24, r18
|
|
|
554 |
242: 8f 5f subi r24, 0xFF ; 255
|
|
|
555 |
244: 87 70 andi r24, 0x07 ; 7
|
|
|
556 |
Exec_eventFifoTail = tmpTail;
|
|
|
557 |
246: 80 93 71 00 sts 0x0071, r24
|
|
|
558 |
ENABLE_INTS();
|
|
|
559 |
24a: 78 94 sei
|
|
|
560 |
|
|
|
561 |
return(dataByte);
|
|
|
562 |
24c: 89 2f mov r24, r25
|
|
|
563 |
24e: 99 27 eor r25, r25
|
|
|
564 |
}
|
|
|
565 |
250: 08 95 ret
|
|
|
566 |
|
|
|
567 |
00000252 <Exec_writeEventFifo>:
|
|
|
568 |
|
|
|
569 |
/***********************************************************
|
|
|
570 |
Function Name: Exec_writeEventFifo
|
|
|
571 |
Function Description: This function is responsible for
|
|
|
572 |
writing a single event to the event fifo and
|
|
|
573 |
updating the appropriate pointers.
|
|
|
574 |
Inputs: data - the byte to write to the Fifo
|
|
|
575 |
Outputs: none
|
|
|
576 |
***********************************************************/
|
|
|
577 |
void Exec_writeEventFifo(unsigned char event)
|
|
|
578 |
{
|
|
|
579 |
252: 38 2f mov r19, r24
|
|
|
580 |
unsigned char tmpHead;
|
|
|
581 |
|
|
|
582 |
DISABLE_INTS();
|
|
|
583 |
254: f8 94 cli
|
|
|
584 |
Exec_eventFifo[Exec_eventFifoHead] = event;
|
|
|
585 |
256: 20 91 70 00 lds r18, 0x0070
|
|
|
586 |
25a: 8c e6 ldi r24, 0x6C ; 108
|
|
|
587 |
25c: 92 e0 ldi r25, 0x02 ; 2
|
|
|
588 |
25e: fc 01 movw r30, r24
|
|
|
589 |
260: e2 0f add r30, r18
|
|
|
590 |
262: f1 1d adc r31, r1
|
|
|
591 |
264: 30 83 st Z, r19
|
|
|
592 |
|
|
|
593 |
/* now move the head up */
|
|
|
594 |
tmpHead = (Exec_eventFifoHead + 1) & (EXEC_EVENT_FIFO_MASK);
|
|
|
595 |
266: 82 2f mov r24, r18
|
|
|
596 |
268: 8f 5f subi r24, 0xFF ; 255
|
|
|
597 |
26a: 87 70 andi r24, 0x07 ; 7
|
|
|
598 |
Exec_eventFifoHead = tmpHead;
|
|
|
599 |
26c: 80 93 70 00 sts 0x0070, r24
|
|
|
600 |
ENABLE_INTS();
|
|
|
601 |
270: 78 94 sei
|
|
|
602 |
}
|
|
|
603 |
272: 08 95 ret
|
|
|
604 |
|
|
|
605 |
00000274 <FrameMgr_init>:
|
|
|
606 |
Outputs: none
|
|
|
607 |
***********************************************************/
|
|
|
608 |
void FrameMgr_init(void)
|
|
|
609 |
{
|
|
|
610 |
memset(trackedObjectTable,0x00,sizeof(trackedObjectTable));
|
|
|
611 |
274: 80 e4 ldi r24, 0x40 ; 64
|
|
|
612 |
276: e8 e7 ldi r30, 0x78 ; 120
|
|
|
613 |
278: f0 e0 ldi r31, 0x00 ; 0
|
|
|
614 |
27a: 11 92 st Z+, r1
|
|
|
615 |
27c: 8a 95 dec r24
|
|
|
616 |
27e: e9 f7 brne .-6 ; 0x27a
|
|
|
617 |
}
|
|
|
618 |
280: 08 95 ret
|
|
|
619 |
|
|
|
620 |
00000282 <FrameMgr_dispatchEvent>:
|
|
|
621 |
|
|
|
622 |
|
|
|
623 |
/***********************************************************
|
|
|
624 |
Function Name: FrameMgr_dispatchEvent
|
|
|
625 |
Function Description: This function is responsible for
|
|
|
626 |
taking an incoming event and performing the needed
|
|
|
627 |
actions with it as pertains to the FrameMgr.
|
|
|
628 |
Inputs: event - the generated event
|
|
|
629 |
Outputs: none
|
|
|
630 |
***********************************************************/
|
|
|
631 |
void FrameMgr_dispatchEvent(unsigned char event)
|
|
|
632 |
{
|
|
|
633 |
switch(event)
|
|
|
634 |
282: 99 27 eor r25, r25
|
|
|
635 |
284: 84 30 cpi r24, 0x04 ; 4
|
|
|
636 |
286: 91 05 cpc r25, r1
|
|
|
637 |
288: 51 f1 breq .+84 ; 0x2de
|
|
|
638 |
28a: 85 30 cpi r24, 0x05 ; 5
|
|
|
639 |
28c: 91 05 cpc r25, r1
|
|
|
640 |
28e: 34 f4 brge .+12 ; 0x29c
|
|
|
641 |
290: 81 30 cpi r24, 0x01 ; 1
|
|
|
642 |
292: 91 05 cpc r25, r1
|
|
|
643 |
294: 31 f1 breq .+76 ; 0x2e2
|
|
|
644 |
296: 02 97 sbiw r24, 0x02 ; 2
|
|
|
645 |
298: 71 f0 breq .+28 ; 0x2b6
|
|
|
646 |
{
|
|
|
647 |
case EV_DUMP_FRAME:
|
|
|
648 |
/* try re-initializing the camera before we start dumping */
|
|
|
649 |
|
|
|
650 |
CamConfig_setCamReg(0x11,0x01); /* reduce the frame rate for dumping*/
|
|
|
651 |
CamConfig_sendFifoCmds();
|
|
|
652 |
Utility_delay(1000); /* allow the new frame rate to settle */
|
|
|
653 |
lineCount = 0;
|
|
|
654 |
currentState = ST_FrameMgr_DumpingFrame;
|
|
|
655 |
//CamIntAsm_waitForNewDumpFrame(currentLineBuffer,previousLineBuffer);
|
|
|
656 |
FrameMgr_acquireLine();
|
|
|
657 |
break;
|
|
|
658 |
|
|
|
659 |
case EV_ENABLE_TRACKING:
|
|
|
660 |
currentState = ST_FrameMgr_TrackingFrame;
|
|
|
661 |
FrameMgr_acquireFrame();
|
|
|
662 |
break;
|
|
|
663 |
|
|
|
664 |
case EV_ACQUIRE_FRAME_COMPLETE:
|
|
|
665 |
FrameMgr_processFrame();
|
|
|
666 |
break;
|
|
|
667 |
|
|
|
668 |
case EV_PROCESS_FRAME_COMPLETE:
|
|
|
669 |
FrameMgr_acquireFrame();
|
|
|
670 |
break;
|
|
|
671 |
|
|
|
672 |
case EV_SERIAL_DATA_RECEIVED:
|
|
|
673 |
if (currentState != ST_FrameMgr_idle)
|
|
|
674 |
{
|
|
|
675 |
/* we need to go back to processing line data, since
|
|
|
676 |
serial data reception interrupted us....just trash the
|
|
|
677 |
frame and act like the frame has been processed, which
|
|
|
678 |
will kick off the system to wait for the next line */
|
|
|
679 |
PUBLISH_EVENT(EV_PROCESS_FRAME_COMPLETE);
|
|
|
680 |
}
|
|
|
681 |
break;
|
|
|
682 |
|
|
|
683 |
case EV_DISABLE_TRACKING:
|
|
|
684 |
/* tracking needs to be turned off */
|
|
|
685 |
currentState = ST_FrameMgr_idle;
|
|
|
686 |
break;
|
|
|
687 |
}
|
|
|
688 |
}
|
|
|
689 |
29a: 08 95 ret
|
|
|
690 |
29c: 80 38 cpi r24, 0x80 ; 128
|
|
|
691 |
29e: 91 05 cpc r25, r1
|
|
|
692 |
2a0: c1 f0 breq .+48 ; 0x2d2
|
|
|
693 |
2a2: 81 38 cpi r24, 0x81 ; 129
|
|
|
694 |
2a4: 91 05 cpc r25, r1
|
|
|
695 |
2a6: 1c f4 brge .+6 ; 0x2ae
|
|
|
696 |
2a8: 80 97 sbiw r24, 0x20 ; 32
|
|
|
697 |
2aa: b9 f0 breq .+46 ; 0x2da
|
|
|
698 |
2ac: 08 95 ret
|
|
|
699 |
2ae: 81 38 cpi r24, 0x81 ; 129
|
|
|
700 |
2b0: 91 05 cpc r25, r1
|
|
|
701 |
2b2: f1 f0 breq .+60 ; 0x2f0
|
|
|
702 |
2b4: 08 95 ret
|
|
|
703 |
2b6: 61 e0 ldi r22, 0x01 ; 1
|
|
|
704 |
2b8: 81 e1 ldi r24, 0x11 ; 17
|
|
|
705 |
2ba: 66 d5 rcall .+2764 ; 0xd88
|
|
|
706 |
2bc: 6a d5 rcall .+2772 ; 0xd92
|
|
|
707 |
2be: 88 ee ldi r24, 0xE8 ; 232
|
|
|
708 |
2c0: 93 e0 ldi r25, 0x03 ; 3
|
|
|
709 |
2c2: c1 d5 rcall .+2946 ; 0xe46
|
|
|
710 |
2c4: 10 92 73 00 sts 0x0073, r1
|
|
|
711 |
2c8: 82 e0 ldi r24, 0x02 ; 2
|
|
|
712 |
2ca: 80 93 74 00 sts 0x0074, r24
|
|
|
713 |
2ce: 2f d0 rcall .+94 ; 0x32e
|
|
|
714 |
2d0: 08 95 ret
|
|
|
715 |
2d2: 81 e0 ldi r24, 0x01 ; 1
|
|
|
716 |
2d4: 80 93 74 00 sts 0x0074, r24
|
|
|
717 |
2d8: 02 c0 rjmp .+4 ; 0x2de
|
|
|
718 |
2da: 18 d1 rcall .+560 ; 0x50c
|
|
|
719 |
2dc: 08 95 ret
|
|
|
720 |
2de: 0c d0 rcall .+24 ; 0x2f8
|
|
|
721 |
2e0: 08 95 ret
|
|
|
722 |
2e2: 80 91 74 00 lds r24, 0x0074
|
|
|
723 |
2e6: 88 23 and r24, r24
|
|
|
724 |
2e8: 29 f0 breq .+10 ; 0x2f4
|
|
|
725 |
2ea: 84 e0 ldi r24, 0x04 ; 4
|
|
|
726 |
2ec: b2 df rcall .-156 ; 0x252
|
|
|
727 |
2ee: 08 95 ret
|
|
|
728 |
2f0: 10 92 74 00 sts 0x0074, r1
|
|
|
729 |
2f4: 08 95 ret
|
|
|
730 |
2f6: 08 95 ret
|
|
|
731 |
|
|
|
732 |
000002f8 <FrameMgr_acquireFrame>:
|
|
|
733 |
|
|
|
734 |
/***********************************************************
|
|
|
735 |
Function Name: FrameMgr_acquireFrame
|
|
|
736 |
Function Description: This function is responsible for
|
|
|
737 |
beginning of the acquisition of a new frame of data
|
|
|
738 |
from the camera interface. The acquisition of this line
|
|
|
739 |
depends on the current state of the FrameMgr.
|
|
|
740 |
Inputs: none
|
|
|
741 |
Outputs: none
|
|
|
742 |
***********************************************************/
|
|
|
743 |
void FrameMgr_acquireFrame(void)
|
|
|
744 |
{
|
|
|
745 |
if (currentState == ST_FrameMgr_TrackingFrame)
|
|
|
746 |
2f8: 80 91 74 00 lds r24, 0x0074
|
|
|
747 |
2fc: 81 30 cpi r24, 0x01 ; 1
|
|
|
748 |
2fe: a9 f4 brne .+42 ; 0x32a
|
|
|
749 |
{
|
|
|
750 |
trackedLineCount = 0;
|
|
|
751 |
300: 10 92 77 00 sts 0x0077, r1
|
|
|
752 |
numPrevTrackedObjects = numCurrTrackedObjects;
|
|
|
753 |
304: 80 91 75 00 lds r24, 0x0075
|
|
|
754 |
308: 80 93 76 00 sts 0x0076, r24
|
|
|
755 |
numCurrTrackedObjects = 0;
|
|
|
756 |
30c: 10 92 75 00 sts 0x0075, r1
|
|
|
757 |
|
|
|
758 |
/* clear out the tracking table, and wait for the new frame
|
|
|
759 |
to start */
|
|
|
760 |
memset(trackedObjectTable,0x00,sizeof(trackedObjectTable));
|
|
|
761 |
310: 80 e4 ldi r24, 0x40 ; 64
|
|
|
762 |
312: e8 e7 ldi r30, 0x78 ; 120
|
|
|
763 |
314: f0 e0 ldi r31, 0x00 ; 0
|
|
|
764 |
316: 11 92 st Z+, r1
|
|
|
765 |
318: 8a 95 dec r24
|
|
|
766 |
31a: e9 f7 brne .-6 ; 0x316
|
|
|
767 |
//CamIntAsm_waitForNewTrackingFrame(currentLineBuffer,colorMap);
|
|
|
768 |
WAIT_FOR_VSYNC_HIGH();
|
|
|
769 |
31c: 82 9b sbis 0x10, 2 ; 16
|
|
|
770 |
31e: fe cf rjmp .-4 ; 0x31c
|
|
|
771 |
CamIntAsm_acquireTrackingLine(currentLineBuffer,colorMap);
|
|
|
772 |
320: 60 e0 ldi r22, 0x00 ; 0
|
|
|
773 |
322: 73 e0 ldi r23, 0x03 ; 3
|
|
|
774 |
324: 8c eb ldi r24, 0xBC ; 188
|
|
|
775 |
326: 91 e0 ldi r25, 0x01 ; 1
|
|
|
776 |
328: f0 d5 rcall .+3040 ; 0xf0a
|
|
|
777 |
}
|
|
|
778 |
}
|
|
|
779 |
32a: 08 95 ret
|
|
|
780 |
32c: 08 95 ret
|
|
|
781 |
|
|
|
782 |
0000032e <FrameMgr_acquireLine>:
|
|
|
783 |
|
|
|
784 |
/***********************************************************
|
|
|
785 |
Function Name: FrameMgr_acquireLine
|
|
|
786 |
Function Description: This function is responsible for
|
|
|
787 |
acquiring a line of data from the camera interface.
|
|
|
788 |
The acquisition of this line depends on the current
|
|
|
789 |
state of the FrameMgr.
|
|
|
790 |
Inputs: none
|
|
|
791 |
Outputs: none
|
|
|
792 |
***********************************************************/
|
|
|
793 |
void FrameMgr_acquireLine(void)
|
|
|
794 |
{
|
|
|
795 |
unsigned char tmpLineCount;
|
|
|
796 |
|
|
|
797 |
/* clearing out the buffers takes too long...we should
|
|
|
798 |
just overwrite the data here without a problem when
|
|
|
799 |
we start acquiring...at no point do we check for
|
|
|
800 |
a 0x00 value in the current or previous lineBuffers,
|
|
|
801 |
so it was a bit excessive :-) */
|
|
|
802 |
|
|
|
803 |
/* check which state we are in and proceed as needed */
|
|
|
804 |
if (currentState == ST_FrameMgr_DumpingFrame)
|
|
|
805 |
32e: 80 91 74 00 lds r24, 0x0074
|
|
|
806 |
332: 82 30 cpi r24, 0x02 ; 2
|
|
|
807 |
334: 11 f5 brne .+68 ; 0x37a
|
|
|
808 |
{
|
|
|
809 |
tmpLineCount = lineCount*2;
|
|
|
810 |
336: 80 91 73 00 lds r24, 0x0073
|
|
|
811 |
33a: 88 0f add r24, r24
|
|
|
812 |
|
|
|
813 |
/* clearing out the line data in dump mode is ok, and actually
|
|
|
814 |
is needed, since it is possible for the first dump line in
|
|
|
815 |
a frame to come back with the last line captured of the
|
|
|
816 |
last capture session...*/
|
|
|
817 |
memset(currentLineBuffer,0x00,LENGTH_OF_LINE_BUFFER);
|
|
|
818 |
33c: 90 eb ldi r25, 0xB0 ; 176
|
|
|
819 |
33e: ec eb ldi r30, 0xBC ; 188
|
|
|
820 |
340: f1 e0 ldi r31, 0x01 ; 1
|
|
|
821 |
342: 11 92 st Z+, r1
|
|
|
822 |
344: 9a 95 dec r25
|
|
|
823 |
346: e9 f7 brne .-6 ; 0x342
|
|
|
824 |
memset(previousLineBuffer,0x00,LENGTH_OF_LINE_BUFFER);
|
|
|
825 |
348: 90 eb ldi r25, 0xB0 ; 176
|
|
|
826 |
34a: ec e0 ldi r30, 0x0C ; 12
|
|
|
827 |
34c: f1 e0 ldi r31, 0x01 ; 1
|
|
|
828 |
34e: 11 92 st Z+, r1
|
|
|
829 |
350: 9a 95 dec r25
|
|
|
830 |
352: e9 f7 brne .-6 ; 0x34e
|
|
|
831 |
/* wait for another VSYNC so we know which frame to use
|
|
|
832 |
to start looking for a line to receive */
|
|
|
833 |
WAIT_FOR_VSYNC_HIGH();
|
|
|
834 |
354: 82 9b sbis 0x10, 2 ; 16
|
|
|
835 |
356: fe cf rjmp .-4 ; 0x354
|
|
|
836 |
WAIT_FOR_VSYNC_LOW();
|
|
|
837 |
358: 82 99 sbic 0x10, 2 ; 16
|
|
|
838 |
35a: fe cf rjmp .-4 ; 0x358
|
|
|
839 |
|
|
|
840 |
/* look at lineCount to determine how many HREFs we should
|
|
|
841 |
wait before we start sampling */
|
|
|
842 |
while(tmpLineCount != 0)
|
|
|
843 |
35c: 88 23 and r24, r24
|
|
|
844 |
35e: 39 f0 breq .+14 ; 0x36e
|
|
|
845 |
{
|
|
|
846 |
WAIT_FOR_HREF_HIGH();
|
|
|
847 |
360: 84 9b sbis 0x10, 4 ; 16
|
|
|
848 |
362: fe cf rjmp .-4 ; 0x360
|
|
|
849 |
tmpLineCount--;
|
|
|
850 |
364: 81 50 subi r24, 0x01 ; 1
|
|
|
851 |
WAIT_FOR_HREF_LOW();
|
|
|
852 |
366: 84 99 sbic 0x10, 4 ; 16
|
|
|
853 |
368: fe cf rjmp .-4 ; 0x366
|
|
|
854 |
36a: 88 23 and r24, r24
|
|
|
855 |
36c: c9 f7 brne .-14 ; 0x360
|
|
|
856 |
}
|
|
|
857 |
|
|
|
858 |
/* we should now be ready to sample our line...*/
|
|
|
859 |
CamIntAsm_acquireDumpLine(currentLineBuffer,previousLineBuffer);
|
|
|
860 |
36e: 6c e0 ldi r22, 0x0C ; 12
|
|
|
861 |
370: 71 e0 ldi r23, 0x01 ; 1
|
|
|
862 |
372: 8c eb ldi r24, 0xBC ; 188
|
|
|
863 |
374: 91 e0 ldi r25, 0x01 ; 1
|
|
|
864 |
376: 10 d6 rcall .+3104 ; 0xf98
|
|
|
865 |
}
|
|
|
866 |
else if (currentState == ST_FrameMgr_TrackingFrame)
|
|
|
867 |
{
|
|
|
868 |
WAIT_FOR_HREF_LOW();
|
|
|
869 |
CamIntAsm_acquireTrackingLine(currentLineBuffer,colorMap);
|
|
|
870 |
}
|
|
|
871 |
}
|
|
|
872 |
378: 08 95 ret
|
|
|
873 |
37a: 80 91 74 00 lds r24, 0x0074
|
|
|
874 |
37e: 81 30 cpi r24, 0x01 ; 1
|
|
|
875 |
380: 39 f4 brne .+14 ; 0x390
|
|
|
876 |
382: 84 99 sbic 0x10, 4 ; 16
|
|
|
877 |
384: fe cf rjmp .-4 ; 0x382
|
|
|
878 |
386: 60 e0 ldi r22, 0x00 ; 0
|
|
|
879 |
388: 73 e0 ldi r23, 0x03 ; 3
|
|
|
880 |
38a: 8c eb ldi r24, 0xBC ; 188
|
|
|
881 |
38c: 91 e0 ldi r25, 0x01 ; 1
|
|
|
882 |
38e: bd d5 rcall .+2938 ; 0xf0a
|
|
|
883 |
390: 08 95 ret
|
|
|
884 |
|
|
|
885 |
00000392 <FrameMgr_processLine>:
|
|
|
886 |
|
|
|
887 |
/***********************************************************
|
|
|
888 |
Function Name: FrameMgr_processLine
|
|
|
889 |
Function Description: This function is responsible for
|
|
|
890 |
parsing the received image line and performing either
|
|
|
891 |
connected region mapping (if in the Tracking state) or
|
|
|
892 |
sending out the raw sampled data (if in the Dumping
|
|
|
893 |
state).
|
|
|
894 |
Inputs: none
|
|
|
895 |
Outputs: none
|
|
|
896 |
***********************************************************/
|
|
|
897 |
void FrameMgr_processLine(void)
|
|
|
898 |
{
|
|
|
899 |
392: df 92 push r13
|
|
|
900 |
394: ef 92 push r14
|
|
|
901 |
396: ff 92 push r15
|
|
|
902 |
398: 0f 93 push r16
|
|
|
903 |
39a: 1f 93 push r17
|
|
|
904 |
39c: cf 93 push r28
|
|
|
905 |
39e: df 93 push r29
|
|
|
906 |
3a0: cd b7 in r28, 0x3d ; 61
|
|
|
907 |
3a2: de b7 in r29, 0x3e ; 62
|
|
|
908 |
3a4: 21 97 sbiw r28, 0x01 ; 1
|
|
|
909 |
3a6: 0f b6 in r0, 0x3f ; 63
|
|
|
910 |
3a8: f8 94 cli
|
|
|
911 |
3aa: de bf out 0x3e, r29 ; 62
|
|
|
912 |
3ac: 0f be out 0x3f, r0 ; 63
|
|
|
913 |
3ae: cd bf out 0x3d, r28 ; 61
|
|
|
914 |
unsigned char i;
|
|
|
915 |
volatile unsigned char dataToSend;
|
|
|
916 |
unsigned char *pTrackedObjectData = (unsigned char *)pCurrentTrackedObjectTable;
|
|
|
917 |
3b0: 00 91 60 00 lds r16, 0x0060
|
|
|
918 |
3b4: 10 91 61 00 lds r17, 0x0061
|
|
|
919 |
#ifdef DEBUG_TRACKED_LINE
|
|
|
920 |
unsigned char *pSendData;
|
|
|
921 |
unsigned char asciiBuffer[5];
|
|
|
922 |
unsigned char pixelCount = 0;
|
|
|
923 |
#endif
|
|
|
924 |
|
|
|
925 |
if (currentState == ST_FrameMgr_DumpingFrame)
|
|
|
926 |
3b8: 80 91 74 00 lds r24, 0x0074
|
|
|
927 |
3bc: 82 30 cpi r24, 0x02 ; 2
|
|
|
928 |
3be: 09 f0 breq .+2 ; 0x3c2
|
|
|
929 |
3c0: 54 c0 rjmp .+168 ; 0x46a
|
|
|
930 |
{
|
|
|
931 |
/* we want to sit in a tight loop and send the acquired data
|
|
|
932 |
sitting in current and previous line buffers out the serial
|
|
|
933 |
port...it is sent out the serial port immediately instead
|
|
|
934 |
of going into the UIMgr tx fifo because we can't do anything
|
|
|
935 |
until its sent out anyway...may as well just get it out now */
|
|
|
936 |
|
|
|
937 |
/* currentLineBuffer is getting "g" previousLineBuffer is getting "b-r" */
|
|
|
938 |
UartInt_txByte(0x0B); /* send the header byte */
|
|
|
939 |
3c2: 8b e0 ldi r24, 0x0B ; 11
|
|
|
940 |
3c4: cd d3 rcall .+1946 ; 0xb60
|
|
|
941 |
UartInt_txByte(lineCount); /* send the line count */
|
|
|
942 |
3c6: 80 91 73 00 lds r24, 0x0073
|
|
|
943 |
3ca: ca d3 rcall .+1940 ; 0xb60
|
|
|
944 |
for (i=0; i<NUM_PIXELS_IN_A_DUMP_LINE; i+=2)
|
|
|
945 |
3cc: dd 24 eor r13, r13
|
|
|
946 |
{
|
|
|
947 |
/* when a dump line is sampled, the upper byte can potentially
|
|
|
948 |
have garbage in it...we don't have time to mask it off as we're
|
|
|
949 |
sampling, so it is done here before we send it out...we also
|
|
|
950 |
combine the samples together so we really are sending up a
|
|
|
951 |
sample for line N as well as line N+1 */
|
|
|
952 |
dataToSend = currentLineBuffer[i];
|
|
|
953 |
3ce: 2d 2d mov r18, r13
|
|
|
954 |
3d0: 33 27 eor r19, r19
|
|
|
955 |
3d2: 0f 2e mov r0, r31
|
|
|
956 |
3d4: fc eb ldi r31, 0xBC ; 188
|
|
|
957 |
3d6: ef 2e mov r14, r31
|
|
|
958 |
3d8: f1 e0 ldi r31, 0x01 ; 1
|
|
|
959 |
3da: ff 2e mov r15, r31
|
|
|
960 |
3dc: f0 2d mov r31, r0
|
|
|
961 |
3de: e2 0e add r14, r18
|
|
|
962 |
3e0: f3 1e adc r15, r19
|
|
|
963 |
3e2: f7 01 movw r30, r14
|
|
|
964 |
3e4: 80 81 ld r24, Z
|
|
|
965 |
3e6: 89 83 std Y+1, r24 ; 0x01
|
|
|
966 |
dataToSend &= 0x0F;
|
|
|
967 |
3e8: 89 81 ldd r24, Y+1 ; 0x01
|
|
|
968 |
3ea: 8f 70 andi r24, 0x0F ; 15
|
|
|
969 |
3ec: 89 83 std Y+1, r24 ; 0x01
|
|
|
970 |
dataToSend <<= 4;
|
|
|
971 |
3ee: 89 81 ldd r24, Y+1 ; 0x01
|
|
|
972 |
3f0: 82 95 swap r24
|
|
|
973 |
3f2: 80 7f andi r24, 0xF0 ; 240
|
|
|
974 |
3f4: 89 83 std Y+1, r24 ; 0x01
|
|
|
975 |
dataToSend |= (previousLineBuffer[i] & 0x0F);
|
|
|
976 |
3f6: 89 01 movw r16, r18
|
|
|
977 |
3f8: 04 5f subi r16, 0xF4 ; 244
|
|
|
978 |
3fa: 1e 4f sbci r17, 0xFE ; 254
|
|
|
979 |
3fc: f8 01 movw r30, r16
|
|
|
980 |
3fe: 80 81 ld r24, Z
|
|
|
981 |
400: 98 2f mov r25, r24
|
|
|
982 |
402: 9f 70 andi r25, 0x0F ; 15
|
|
|
983 |
404: 89 81 ldd r24, Y+1 ; 0x01
|
|
|
984 |
406: 89 2b or r24, r25
|
|
|
985 |
408: 89 83 std Y+1, r24 ; 0x01
|
|
|
986 |
|
|
|
987 |
/* dataToSend should be packed now */
|
|
|
988 |
UartInt_txByte(dataToSend);
|
|
|
989 |
40a: 89 81 ldd r24, Y+1 ; 0x01
|
|
|
990 |
40c: a9 d3 rcall .+1874 ; 0xb60
|
|
|
991 |
|
|
|
992 |
/* flip the colors around since we are doing all G on Y and BR on UV */
|
|
|
993 |
dataToSend = previousLineBuffer[i+1];
|
|
|
994 |
40e: f8 01 movw r30, r16
|
|
|
995 |
410: 81 81 ldd r24, Z+1 ; 0x01
|
|
|
996 |
412: 89 83 std Y+1, r24 ; 0x01
|
|
|
997 |
dataToSend &= 0x0F;
|
|
|
998 |
414: 89 81 ldd r24, Y+1 ; 0x01
|
|
|
999 |
416: 8f 70 andi r24, 0x0F ; 15
|
|
|
1000 |
418: 89 83 std Y+1, r24 ; 0x01
|
|
|
1001 |
dataToSend <<= 4;
|
|
|
1002 |
41a: 89 81 ldd r24, Y+1 ; 0x01
|
|
|
1003 |
41c: 82 95 swap r24
|
|
|
1004 |
41e: 80 7f andi r24, 0xF0 ; 240
|
|
|
1005 |
420: 89 83 std Y+1, r24 ; 0x01
|
|
|
1006 |
dataToSend |= (currentLineBuffer[i+1] & 0x0F);
|
|
|
1007 |
422: f7 01 movw r30, r14
|
|
|
1008 |
424: 81 81 ldd r24, Z+1 ; 0x01
|
|
|
1009 |
426: 98 2f mov r25, r24
|
|
|
1010 |
428: 9f 70 andi r25, 0x0F ; 15
|
|
|
1011 |
42a: 89 81 ldd r24, Y+1 ; 0x01
|
|
|
1012 |
42c: 89 2b or r24, r25
|
|
|
1013 |
42e: 89 83 std Y+1, r24 ; 0x01
|
|
|
1014 |
|
|
|
1015 |
/* dataToSend should be packed now */
|
|
|
1016 |
UartInt_txByte(dataToSend);
|
|
|
1017 |
430: 89 81 ldd r24, Y+1 ; 0x01
|
|
|
1018 |
432: 96 d3 rcall .+1836 ; 0xb60
|
|
|
1019 |
434: f2 e0 ldi r31, 0x02 ; 2
|
|
|
1020 |
436: df 0e add r13, r31
|
|
|
1021 |
438: 4f ea ldi r20, 0xAF ; 175
|
|
|
1022 |
43a: 4d 15 cp r20, r13
|
|
|
1023 |
43c: 40 f6 brcc .-112 ; 0x3ce
|
|
|
1024 |
}
|
|
|
1025 |
UartInt_txByte(0x0F); /* send line end */
|
|
|
1026 |
43e: 8f e0 ldi r24, 0x0F ; 15
|
|
|
1027 |
440: 8f d3 rcall .+1822 ; 0xb60
|
|
|
1028 |
/* once all the data is sent, increment out line count by 2 since
|
|
|
1029 |
we really get 2 lines worth of pixels on each pass */
|
|
|
1030 |
/* Update...increment only by 1, but only send 72 double-lines */
|
|
|
1031 |
lineCount++;
|
|
|
1032 |
442: 80 91 73 00 lds r24, 0x0073
|
|
|
1033 |
446: 8f 5f subi r24, 0xFF ; 255
|
|
|
1034 |
448: 80 93 73 00 sts 0x0073, r24
|
|
|
1035 |
|
|
|
1036 |
/* check to see if we have retrieved all of the needed lines */
|
|
|
1037 |
if (lineCount >= 72) /* half 144, since we send two lines at a time */
|
|
|
1038 |
44c: 88 34 cpi r24, 0x48 ; 72
|
|
|
1039 |
44e: 08 f4 brcc .+2 ; 0x452
|
|
|
1040 |
450: 4a c0 rjmp .+148 ; 0x4e6
|
|
|
1041 |
{
|
|
|
1042 |
/* we're done, so send the dump complete?...nope, just change
|
|
|
1043 |
states and we should be fine */
|
|
|
1044 |
lineCount = 0;
|
|
|
1045 |
452: 10 92 73 00 sts 0x0073, r1
|
|
|
1046 |
currentState = ST_FrameMgr_idle;
|
|
|
1047 |
456: 10 92 74 00 sts 0x0074, r1
|
|
|
1048 |
|
|
|
1049 |
/* disable the PCLK counting overflow interrupt */
|
|
|
1050 |
TIMSK &= DISABLE_PCLK_TIMER1_OVERFLOW_BITMASK;
|
|
|
1051 |
45a: 89 b7 in r24, 0x39 ; 57
|
|
|
1052 |
45c: 8b 7f andi r24, 0xFB ; 251
|
|
|
1053 |
45e: 89 bf out 0x39, r24 ; 57
|
|
|
1054 |
|
|
|
1055 |
CamConfig_setCamReg(0x11,0x00); /* reset the frame rate to normal*/
|
|
|
1056 |
460: 60 e0 ldi r22, 0x00 ; 0
|
|
|
1057 |
462: 81 e1 ldi r24, 0x11 ; 17
|
|
|
1058 |
464: 91 d4 rcall .+2338 ; 0xd88
|
|
|
1059 |
CamConfig_sendFifoCmds();
|
|
|
1060 |
466: 95 d4 rcall .+2346 ; 0xd92
|
|
|
1061 |
468: 43 c0 rjmp .+134 ; 0x4f0
|
|
|
1062 |
}
|
|
|
1063 |
else
|
|
|
1064 |
{
|
|
|
1065 |
/* we have more lines to acquire in this frame, so keep on truckin...*/
|
|
|
1066 |
PUBLISH_FAST_EVENT(FEV_PROCESS_LINE_COMPLETE);
|
|
|
1067 |
}
|
|
|
1068 |
}
|
|
|
1069 |
else if (currentState == ST_FrameMgr_TrackingFrame)
|
|
|
1070 |
46a: 80 91 74 00 lds r24, 0x0074
|
|
|
1071 |
46e: 81 30 cpi r24, 0x01 ; 1
|
|
|
1072 |
470: 09 f0 breq .+2 ; 0x474
|
|
|
1073 |
472: 3e c0 rjmp .+124 ; 0x4f0
|
|
|
1074 |
{
|
|
|
1075 |
#ifdef DEBUG_TRACKED_LINE
|
|
|
1076 |
/* send the received line over serial...this should only send
|
|
|
1077 |
until a pixelCount == 176 */
|
|
|
1078 |
pSendData = currentLineBuffer;
|
|
|
1079 |
itoa(trackedLineCount,asciiBuffer,10);
|
|
|
1080 |
UIMgr_txBuffer(asciiBuffer,3);
|
|
|
1081 |
UIMgr_txBuffer(" ",1);
|
|
|
1082 |
while(pixelCount < ACTUAL_NUM_PIXELS_IN_A_LINE)
|
|
|
1083 |
{
|
|
|
1084 |
memset(asciiBuffer,0x00,5);
|
|
|
1085 |
itoa(*pSendData++,asciiBuffer,10); /* color is first byte */
|
|
|
1086 |
UIMgr_txBuffer(asciiBuffer,3); /* 3 ascii bytes for data */
|
|
|
1087 |
UIMgr_txBuffer(" ",1);
|
|
|
1088 |
|
|
|
1089 |
pixelCount += *pSendData; /* run-length is second byte */
|
|
|
1090 |
memset(asciiBuffer,0x00,5);
|
|
|
1091 |
itoa(*pSendData++,asciiBuffer,10);
|
|
|
1092 |
UIMgr_txBuffer(asciiBuffer,3);
|
|
|
1093 |
UIMgr_txBuffer(" ",1);
|
|
|
1094 |
}
|
|
|
1095 |
UIMgr_txBuffer("\n\r",2);
|
|
|
1096 |
|
|
|
1097 |
trackedLineCount++;
|
|
|
1098 |
if (trackedLineCount == 144)
|
|
|
1099 |
{
|
|
|
1100 |
UIMgr_txBuffer(" FC \n\r",8);
|
|
|
1101 |
trackedLineCount = 0;
|
|
|
1102 |
PUBLISH_EVENT(EV_PROCESS_FRAME_COMPLETE);
|
|
|
1103 |
}
|
|
|
1104 |
else
|
|
|
1105 |
{
|
|
|
1106 |
PUBLISH_EVENT(EV_PROCESS_LINE_COMPLETE);
|
|
|
1107 |
}
|
|
|
1108 |
#else
|
|
|
1109 |
/* determine if any of the RLE blocks overlap */
|
|
|
1110 |
FrameMgr_findConnectedness();
|
|
|
1111 |
474: a1 d0 rcall .+322 ; 0x5b8
|
|
|
1112 |
|
|
|
1113 |
/* we also want to remove any objects that are less than
|
|
|
1114 |
a minimum height...we already removed portions of the
|
|
|
1115 |
run-length that are less than MIN_PIXEL_WIDTH in the
|
|
|
1116 |
findConnectedness() routine...doing it here instead of
|
|
|
1117 |
a function to speed things up...this may end up slowing down the
|
|
|
1118 |
frame rate slightly, and can be removed if this isn't needed */
|
|
|
1119 |
|
|
|
1120 |
/* run this routine once every 8 lines */
|
|
|
1121 |
if ( (trackedLineCount & RUN_OBJECT_FILTER_MASK) == RUN_OBJECT_FILTER_MASK)
|
|
|
1122 |
476: 80 91 77 00 lds r24, 0x0077
|
|
|
1123 |
47a: 99 27 eor r25, r25
|
|
|
1124 |
47c: 87 70 andi r24, 0x07 ; 7
|
|
|
1125 |
47e: 90 70 andi r25, 0x00 ; 0
|
|
|
1126 |
480: 07 97 sbiw r24, 0x07 ; 7
|
|
|
1127 |
482: 11 f5 brne .+68 ; 0x4c8
|
|
|
1128 |
{
|
|
|
1129 |
for (i=0; i<MAX_TRACKED_OBJECTS; i++)
|
|
|
1130 |
484: dd 24 eor r13, r13
|
|
|
1131 |
{
|
|
|
1132 |
if ( *(pTrackedObjectData + VALID_OBJECT_OFFSET) == TRUE)
|
|
|
1133 |
486: f8 01 movw r30, r16
|
|
|
1134 |
488: 87 81 ldd r24, Z+7 ; 0x07
|
|
|
1135 |
48a: 81 30 cpi r24, 0x01 ; 1
|
|
|
1136 |
48c: b9 f4 brne .+46 ; 0x4bc
|
|
|
1137 |
{
|
|
|
1138 |
/* check to see if the object is already in
|
|
|
1139 |
our past...i.e., its last */
|
|
|
1140 |
if ( (*(pTrackedObjectData + Y_LOWER_RIGHT_OFFSET) -
|
|
|
1141 |
48e: 86 81 ldd r24, Z+6 ; 0x06
|
|
|
1142 |
490: 28 2f mov r18, r24
|
|
|
1143 |
492: 33 27 eor r19, r19
|
|
|
1144 |
494: 84 81 ldd r24, Z+4 ; 0x04
|
|
|
1145 |
496: a9 01 movw r20, r18
|
|
|
1146 |
498: 48 1b sub r20, r24
|
|
|
1147 |
49a: 51 09 sbc r21, r1
|
|
|
1148 |
49c: 43 30 cpi r20, 0x03 ; 3
|
|
|
1149 |
49e: 51 05 cpc r21, r1
|
|
|
1150 |
4a0: 6c f4 brge .+26 ; 0x4bc
|
|
|
1151 |
*(pTrackedObjectData + Y_UPPER_LEFT_OFFSET)) < MIN_OBJECT_TRACKING_HEIGHT)
|
|
|
1152 |
{
|
|
|
1153 |
/* the object is less than the minimum height...see if it is adjacent
|
|
|
1154 |
to the current line we just processed...if so, leave it here...otherwise,
|
|
|
1155 |
it needs to be invalidated since its too small */
|
|
|
1156 |
if ( trackedLineCount - *(pTrackedObjectData + Y_LOWER_RIGHT_OFFSET) > 2)
|
|
|
1157 |
4a2: 80 91 77 00 lds r24, 0x0077
|
|
|
1158 |
4a6: 99 27 eor r25, r25
|
|
|
1159 |
4a8: 82 1b sub r24, r18
|
|
|
1160 |
4aa: 93 0b sbc r25, r19
|
|
|
1161 |
4ac: 03 97 sbiw r24, 0x03 ; 3
|
|
|
1162 |
4ae: 34 f0 brlt .+12 ; 0x4bc
|
|
|
1163 |
{
|
|
|
1164 |
/* invalidate the object */
|
|
|
1165 |
*(pTrackedObjectData + VALID_OBJECT_OFFSET) = FALSE;
|
|
|
1166 |
4b0: 17 82 std Z+7, r1 ; 0x07
|
|
|
1167 |
numCurrTrackedObjects--;
|
|
|
1168 |
4b2: 80 91 75 00 lds r24, 0x0075
|
|
|
1169 |
4b6: 81 50 subi r24, 0x01 ; 1
|
|
|
1170 |
4b8: 80 93 75 00 sts 0x0075, r24
|
|
|
1171 |
}
|
|
|
1172 |
}
|
|
|
1173 |
}
|
|
|
1174 |
pTrackedObjectData += SIZE_OF_TRACKED_OBJECT;
|
|
|
1175 |
4bc: 08 5f subi r16, 0xF8 ; 248
|
|
|
1176 |
4be: 1f 4f sbci r17, 0xFF ; 255
|
|
|
1177 |
4c0: d3 94 inc r13
|
|
|
1178 |
4c2: 57 e0 ldi r21, 0x07 ; 7
|
|
|
1179 |
4c4: 5d 15 cp r21, r13
|
|
|
1180 |
4c6: f8 f6 brcc .-66 ; 0x486
|
|
|
1181 |
}
|
|
|
1182 |
}
|
|
|
1183 |
|
|
|
1184 |
trackedLineCount++;
|
|
|
1185 |
4c8: 80 91 77 00 lds r24, 0x0077
|
|
|
1186 |
4cc: 8f 5f subi r24, 0xFF ; 255
|
|
|
1187 |
4ce: 80 93 77 00 sts 0x0077, r24
|
|
|
1188 |
if (trackedLineCount == ACTUAL_NUM_LINES_IN_A_FRAME)
|
|
|
1189 |
4d2: 80 39 cpi r24, 0x90 ; 144
|
|
|
1190 |
4d4: 41 f4 brne .+16 ; 0x4e6
|
|
|
1191 |
{
|
|
|
1192 |
/* an entire frame of tracking data has been acquired, so
|
|
|
1193 |
publish an event letting the system know this fact */
|
|
|
1194 |
PUBLISH_EVENT(EV_ACQUIRE_FRAME_COMPLETE);
|
|
|
1195 |
4d6: 80 e2 ldi r24, 0x20 ; 32
|
|
|
1196 |
4d8: bc de rcall .-648 ; 0x252
|
|
|
1197 |
/* disable the PCLK counting overflow interrupt */
|
|
|
1198 |
TIMSK &= DISABLE_PCLK_TIMER1_OVERFLOW_BITMASK;
|
|
|
1199 |
4da: 89 b7 in r24, 0x39 ; 57
|
|
|
1200 |
4dc: 8b 7f andi r24, 0xFB ; 251
|
|
|
1201 |
4de: 89 bf out 0x39, r24 ; 57
|
|
|
1202 |
trackedLineCount = 0;
|
|
|
1203 |
4e0: 10 92 77 00 sts 0x0077, r1
|
|
|
1204 |
4e4: 05 c0 rjmp .+10 ; 0x4f0
|
|
|
1205 |
}
|
|
|
1206 |
else
|
|
|
1207 |
{
|
|
|
1208 |
PUBLISH_FAST_EVENT(FEV_PROCESS_LINE_COMPLETE);
|
|
|
1209 |
4e6: 80 91 72 00 lds r24, 0x0072
|
|
|
1210 |
4ea: 82 60 ori r24, 0x02 ; 2
|
|
|
1211 |
4ec: 80 93 72 00 sts 0x0072, r24
|
|
|
1212 |
}
|
|
|
1213 |
#endif
|
|
|
1214 |
}
|
|
|
1215 |
else
|
|
|
1216 |
{
|
|
|
1217 |
/* ...and here? */
|
|
|
1218 |
}
|
|
|
1219 |
}
|
|
|
1220 |
4f0: 21 96 adiw r28, 0x01 ; 1
|
|
|
1221 |
4f2: 0f b6 in r0, 0x3f ; 63
|
|
|
1222 |
4f4: f8 94 cli
|
|
|
1223 |
4f6: de bf out 0x3e, r29 ; 62
|
|
|
1224 |
4f8: 0f be out 0x3f, r0 ; 63
|
|
|
1225 |
4fa: cd bf out 0x3d, r28 ; 61
|
|
|
1226 |
4fc: df 91 pop r29
|
|
|
1227 |
4fe: cf 91 pop r28
|
|
|
1228 |
500: 1f 91 pop r17
|
|
|
1229 |
502: 0f 91 pop r16
|
|
|
1230 |
504: ff 90 pop r15
|
|
|
1231 |
506: ef 90 pop r14
|
|
|
1232 |
508: df 90 pop r13
|
|
|
1233 |
50a: 08 95 ret
|
|
|
1234 |
|
|
|
1235 |
0000050c <FrameMgr_processFrame>:
|
|
|
1236 |
|
|
|
1237 |
/***********************************************************
|
|
|
1238 |
Function Name: FrameMgr_processFrame
|
|
|
1239 |
Function Description: This function is responsible for
|
|
|
1240 |
parsing the completed frame and performing all actions
|
|
|
1241 |
needed at this level.
|
|
|
1242 |
Inputs: none
|
|
|
1243 |
Outputs: none
|
|
|
1244 |
***********************************************************/
|
|
|
1245 |
void FrameMgr_processFrame(void)
|
|
|
1246 |
{
|
|
|
1247 |
50c: df 92 push r13
|
|
|
1248 |
50e: ef 92 push r14
|
|
|
1249 |
510: ff 92 push r15
|
|
|
1250 |
512: 0f 93 push r16
|
|
|
1251 |
514: 1f 93 push r17
|
|
|
1252 |
516: cf 93 push r28
|
|
|
1253 |
518: df 93 push r29
|
|
|
1254 |
unsigned char i,k,color;
|
|
|
1255 |
#if DEBUG_FRAME_DATA
|
|
|
1256 |
unsigned char asciiBuffer[5];
|
|
|
1257 |
unsigned char j;
|
|
|
1258 |
#endif
|
|
|
1259 |
unsigned char *pTableData = (unsigned char *)pCurrentTrackedObjectTable;
|
|
|
1260 |
unsigned char tmpUpperLeftX,tmpUpperLeftY,tmpLowerRightX,tmpLowerRightY;
|
|
|
1261 |
|
|
|
1262 |
#if DEBUG_FRAME_DATA
|
|
|
1263 |
/* we want to send all of the currently tracked table out
|
|
|
1264 |
the serial port for debugging */
|
|
|
1265 |
for (i=0; i<numCurrTrackedObjects; i++)
|
|
|
1266 |
{
|
|
|
1267 |
UIMgr_txBuffer("----------\r\n",12);
|
|
|
1268 |
for (j=0; j<SIZE_OF_TRACKED_OBJECT; j++)
|
|
|
1269 |
{
|
|
|
1270 |
memset(asciiBuffer,0x00,5);
|
|
|
1271 |
itoa(*pTableData++,asciiBuffer,10);
|
|
|
1272 |
UIMgr_txBuffer(asciiBuffer,3); /* 3 ascii bytes for data
|
|
|
1273 |
+ 1 space */
|
|
|
1274 |
UIMgr_txBuffer("\r\n",2);
|
|
|
1275 |
}
|
|
|
1276 |
}
|
|
|
1277 |
|
|
|
1278 |
/* finally, send a new line */
|
|
|
1279 |
UIMgr_txBuffer("\r\n",2);
|
|
|
1280 |
|
|
|
1281 |
memset(asciiBuffer,0x00,5);
|
|
|
1282 |
itoa(numCurrTrackedObjects,asciiBuffer,10);
|
|
|
1283 |
UIMgr_txBuffer(asciiBuffer,3);
|
|
|
1284 |
UIMgr_txBuffer(" PFC\r\n",5);
|
|
|
1285 |
|
|
|
1286 |
#else
|
|
|
1287 |
/* we only send tracking packets if there are tracked objects */
|
|
|
1288 |
|
|
|
1289 |
if (numCurrTrackedObjects > 0)
|
|
|
1290 |
51a: 80 91 75 00 lds r24, 0x0075
|
|
|
1291 |
51e: 88 23 and r24, r24
|
|
|
1292 |
520: 09 f4 brne .+2 ; 0x524
|
|
|
1293 |
522: 40 c0 rjmp .+128 ; 0x5a4
|
|
|
1294 |
{
|
|
|
1295 |
UIMgr_writeTxFifo(0x0A); /* header byte for a tracking packet */
|
|
|
1296 |
524: 8a e0 ldi r24, 0x0A ; 10
|
|
|
1297 |
526: 01 d3 rcall .+1538 ; 0xb2a
|
|
|
1298 |
/* reset the pointer */
|
|
|
1299 |
pTableData = (unsigned char *)pCurrentTrackedObjectTable;
|
|
|
1300 |
528: c0 91 60 00 lds r28, 0x0060
|
|
|
1301 |
52c: d0 91 61 00 lds r29, 0x0061
|
|
|
1302 |
|
|
|
1303 |
UIMgr_writeTxFifo(numCurrTrackedObjects); /* num of objects tracked */
|
|
|
1304 |
530: 80 91 75 00 lds r24, 0x0075
|
|
|
1305 |
534: fa d2 rcall .+1524 ; 0xb2a
|
|
|
1306 |
for (i=0; i<MAX_TRACKED_OBJECTS; i++)
|
|
|
1307 |
536: dd 24 eor r13, r13
|
|
|
1308 |
{
|
|
|
1309 |
/* we only want to process objects that have their objectValid flag
|
|
|
1310 |
set to TRUE */
|
|
|
1311 |
if ( *(pTableData + VALID_OBJECT_OFFSET) == TRUE)
|
|
|
1312 |
538: 8f 81 ldd r24, Y+7 ; 0x07
|
|
|
1313 |
53a: 81 30 cpi r24, 0x01 ; 1
|
|
|
1314 |
53c: 61 f5 brne .+88 ; 0x596
|
|
|
1315 |
{
|
|
|
1316 |
/* the object is valid...convert the color from bit position to value...remember,
|
|
|
1317 |
each bit in the "color" byte corresponds to a color */
|
|
|
1318 |
k=0;
|
|
|
1319 |
53e: 80 e0 ldi r24, 0x00 ; 0
|
|
|
1320 |
color = *(pTableData + COLOR_OFFSET);
|
|
|
1321 |
540: 98 81 ld r25, Y
|
|
|
1322 |
if (color == 128) k=0;
|
|
|
1323 |
542: 90 38 cpi r25, 0x80 ; 128
|
|
|
1324 |
544: d9 f0 breq .+54 ; 0x57c
|
|
|
1325 |
else if (color == 64) k=1;
|
|
|
1326 |
546: 90 34 cpi r25, 0x40 ; 64
|
|
|
1327 |
548: 11 f4 brne .+4 ; 0x54e
|
|
|
1328 |
54a: 81 e0 ldi r24, 0x01 ; 1
|
|
|
1329 |
54c: 17 c0 rjmp .+46 ; 0x57c
|
|
|
1330 |
else if (color == 32) k=2;
|
|
|
1331 |
54e: 90 32 cpi r25, 0x20 ; 32
|
|
|
1332 |
550: 11 f4 brne .+4 ; 0x556
|
|
|
1333 |
552: 82 e0 ldi r24, 0x02 ; 2
|
|
|
1334 |
554: 13 c0 rjmp .+38 ; 0x57c
|
|
|
1335 |
else if (color == 16) k=3;
|
|
|
1336 |
556: 90 31 cpi r25, 0x10 ; 16
|
|
|
1337 |
558: 11 f4 brne .+4 ; 0x55e
|
|
|
1338 |
55a: 83 e0 ldi r24, 0x03 ; 3
|
|
|
1339 |
55c: 0f c0 rjmp .+30 ; 0x57c
|
|
|
1340 |
else if (color == 8) k=4;
|
|
|
1341 |
55e: 98 30 cpi r25, 0x08 ; 8
|
|
|
1342 |
560: 11 f4 brne .+4 ; 0x566
|
|
|
1343 |
562: 84 e0 ldi r24, 0x04 ; 4
|
|
|
1344 |
564: 0b c0 rjmp .+22 ; 0x57c
|
|
|
1345 |
else if (color == 4) k=5;
|
|
|
1346 |
566: 94 30 cpi r25, 0x04 ; 4
|
|
|
1347 |
568: 11 f4 brne .+4 ; 0x56e
|
|
|
1348 |
56a: 85 e0 ldi r24, 0x05 ; 5
|
|
|
1349 |
56c: 07 c0 rjmp .+14 ; 0x57c
|
|
|
1350 |
else if (color == 2) k=6;
|
|
|
1351 |
56e: 92 30 cpi r25, 0x02 ; 2
|
|
|
1352 |
570: 11 f4 brne .+4 ; 0x576
|
|
|
1353 |
572: 86 e0 ldi r24, 0x06 ; 6
|
|
|
1354 |
574: 03 c0 rjmp .+6 ; 0x57c
|
|
|
1355 |
else if (color == 1) k=7;
|
|
|
1356 |
576: 91 30 cpi r25, 0x01 ; 1
|
|
|
1357 |
578: 09 f4 brne .+2 ; 0x57c
|
|
|
1358 |
57a: 87 e0 ldi r24, 0x07 ; 7
|
|
|
1359 |
|
|
|
1360 |
tmpUpperLeftX = *(pTableData + X_UPPER_LEFT_OFFSET); /* get the upper left X */
|
|
|
1361 |
57c: 1b 81 ldd r17, Y+3 ; 0x03
|
|
|
1362 |
tmpUpperLeftY = *(pTableData + Y_UPPER_LEFT_OFFSET); /* get the upper left Y */
|
|
|
1363 |
57e: 0c 81 ldd r16, Y+4 ; 0x04
|
|
|
1364 |
tmpLowerRightX = *(pTableData + X_LOWER_RIGHT_OFFSET); /* get the lower right X */
|
|
|
1365 |
580: fd 80 ldd r15, Y+5 ; 0x05
|
|
|
1366 |
tmpLowerRightY = *(pTableData + Y_LOWER_RIGHT_OFFSET); /* get the lower right Y */
|
|
|
1367 |
582: ee 80 ldd r14, Y+6 ; 0x06
|
|
|
1368 |
|
|
|
1369 |
UIMgr_writeTxFifo(k); /* send the color first */
|
|
|
1370 |
584: d2 d2 rcall .+1444 ; 0xb2a
|
|
|
1371 |
UIMgr_writeTxFifo(tmpUpperLeftX);
|
|
|
1372 |
586: 81 2f mov r24, r17
|
|
|
1373 |
588: d0 d2 rcall .+1440 ; 0xb2a
|
|
|
1374 |
UIMgr_writeTxFifo(tmpUpperLeftY);
|
|
|
1375 |
58a: 80 2f mov r24, r16
|
|
|
1376 |
58c: ce d2 rcall .+1436 ; 0xb2a
|
|
|
1377 |
UIMgr_writeTxFifo(tmpLowerRightX);
|
|
|
1378 |
58e: 8f 2d mov r24, r15
|
|
|
1379 |
590: cc d2 rcall .+1432 ; 0xb2a
|
|
|
1380 |
UIMgr_writeTxFifo(tmpLowerRightY);
|
|
|
1381 |
592: 8e 2d mov r24, r14
|
|
|
1382 |
594: ca d2 rcall .+1428 ; 0xb2a
|
|
|
1383 |
}
|
|
|
1384 |
|
|
|
1385 |
/* move our pointer up to the beginning of the next object */
|
|
|
1386 |
pTableData += SIZE_OF_TRACKED_OBJECT;
|
|
|
1387 |
596: 28 96 adiw r28, 0x08 ; 8
|
|
|
1388 |
598: d3 94 inc r13
|
|
|
1389 |
59a: 87 e0 ldi r24, 0x07 ; 7
|
|
|
1390 |
59c: 8d 15 cp r24, r13
|
|
|
1391 |
59e: 60 f6 brcc .-104 ; 0x538
|
|
|
1392 |
}
|
|
|
1393 |
|
|
|
1394 |
/* all done...send the end of tracking packets char */
|
|
|
1395 |
UIMgr_writeTxFifo(0xFF);
|
|
|
1396 |
5a0: 8f ef ldi r24, 0xFF ; 255
|
|
|
1397 |
5a2: c3 d2 rcall .+1414 ; 0xb2a
|
|
|
1398 |
}
|
|
|
1399 |
#endif
|
|
|
1400 |
|
|
|
1401 |
/* the tracked object table will be cleared out right before we start
|
|
|
1402 |
to wait for VSYNC to indicate a new frame...so it doesn't need to be
|
|
|
1403 |
done now */
|
|
|
1404 |
|
|
|
1405 |
/* schedule the next action to acquire a new frame */
|
|
|
1406 |
PUBLISH_EVENT(EV_PROCESS_FRAME_COMPLETE);
|
|
|
1407 |
5a4: 84 e0 ldi r24, 0x04 ; 4
|
|
|
1408 |
5a6: 55 de rcall .-854 ; 0x252
|
|
|
1409 |
}
|
|
|
1410 |
5a8: df 91 pop r29
|
|
|
1411 |
5aa: cf 91 pop r28
|
|
|
1412 |
5ac: 1f 91 pop r17
|
|
|
1413 |
5ae: 0f 91 pop r16
|
|
|
1414 |
5b0: ff 90 pop r15
|
|
|
1415 |
5b2: ef 90 pop r14
|
|
|
1416 |
5b4: df 90 pop r13
|
|
|
1417 |
5b6: 08 95 ret
|
|
|
1418 |
|
|
|
1419 |
000005b8 <FrameMgr_findConnectedness>:
|
|
|
1420 |
|
|
|
1421 |
/***********************************************************
|
|
|
1422 |
Function Name: FrameMgr_findConnectedness
|
|
|
1423 |
Function Description: This function is responsible for
|
|
|
1424 |
finding the connectedness between two particular run-
|
|
|
1425 |
length encoded lines of pixel data. It updates the
|
|
|
1426 |
trackingTable as needed.
|
|
|
1427 |
Inputs: none
|
|
|
1428 |
Outputs: none
|
|
|
1429 |
***********************************************************/
|
|
|
1430 |
static void FrameMgr_findConnectedness(void)
|
|
|
1431 |
{
|
|
|
1432 |
5b8: 1f 93 push r17
|
|
|
1433 |
5ba: cf 93 push r28
|
|
|
1434 |
trackedColor_t currColor;
|
|
|
1435 |
unsigned char *pCurrLineColorInfo = currentLineBuffer;
|
|
|
1436 |
5bc: ac eb ldi r26, 0xBC ; 188
|
|
|
1437 |
5be: b1 e0 ldi r27, 0x01 ; 1
|
|
|
1438 |
unsigned char *pTrackedObjectData;
|
|
|
1439 |
register unsigned char currPixelRunStart=0;
|
|
|
1440 |
5c0: 60 e0 ldi r22, 0x00 ; 0
|
|
|
1441 |
register unsigned char currPixelRunFinish=0;
|
|
|
1442 |
5c2: c6 2f mov r28, r22
|
|
|
1443 |
register unsigned char lastLineXStart=0;
|
|
|
1444 |
register unsigned char lastLineXFinish=0;
|
|
|
1445 |
register unsigned char runLength=1;
|
|
|
1446 |
5c4: 71 e0 ldi r23, 0x01 ; 1
|
|
|
1447 |
unsigned char i;
|
|
|
1448 |
bool_t colorConnected;
|
|
|
1449 |
|
|
|
1450 |
do
|
|
|
1451 |
{
|
|
|
1452 |
/* grab both the current color and the number of pixels
|
|
|
1453 |
in the run...remember, pixels start at 1, not 0! */
|
|
|
1454 |
colorConnected = FALSE;
|
|
|
1455 |
5c6: 10 e0 ldi r17, 0x00 ; 0
|
|
|
1456 |
currColor = *pCurrLineColorInfo++;
|
|
|
1457 |
5c8: 5d 91 ld r21, X+
|
|
|
1458 |
currPixelRunStart += runLength;
|
|
|
1459 |
5ca: c7 0f add r28, r23
|
|
|
1460 |
runLength = *pCurrLineColorInfo++;
|
|
|
1461 |
5cc: 7d 91 ld r23, X+
|
|
|
1462 |
currPixelRunFinish += runLength;
|
|
|
1463 |
5ce: 67 0f add r22, r23
|
|
|
1464 |
|
|
|
1465 |
/* make sure that the run-length is at least as wide as
|
|
|
1466 |
the minimum horizontal tracking width, and we care about the color */
|
|
|
1467 |
|
|
|
1468 |
if ( (currColor != notTracked) && (runLength > MIN_OBJECT_TRACKING_WIDTH) )
|
|
|
1469 |
5d0: 55 23 and r21, r21
|
|
|
1470 |
5d2: 09 f4 brne .+2 ; 0x5d6
|
|
|
1471 |
5d4: 5d c0 rjmp .+186 ; 0x690
|
|
|
1472 |
5d6: 74 30 cpi r23, 0x04 ; 4
|
|
|
1473 |
5d8: 08 f4 brcc .+2 ; 0x5dc
|
|
|
1474 |
5da: 5a c0 rjmp .+180 ; 0x690
|
|
|
1475 |
{
|
|
|
1476 |
/* this run contains a color we care about, so
|
|
|
1477 |
either it will begin a new tracked object, or it
|
|
|
1478 |
is connected to a currently tracked object...
|
|
|
1479 |
compare it with each object in the tracking
|
|
|
1480 |
table...we can't just look at the numTrackedObjects because
|
|
|
1481 |
it is entirely possible that the first couple of objects could
|
|
|
1482 |
be invalid...
|
|
|
1483 |
|
|
|
1484 |
NOTE: Instead of accessing each element in the trackedObjectTable
|
|
|
1485 |
through the 'i' index, and then accessing the fields in each structure,
|
|
|
1486 |
a pointer to each entry is established each time through the loop, followed
|
|
|
1487 |
by accessing the elements through specified offsets. GCC seems to be
|
|
|
1488 |
able to optimize this code much better than simply accessing the elements
|
|
|
1489 |
of each structure in the array the more normal way...*/
|
|
|
1490 |
|
|
|
1491 |
pTrackedObjectData = (unsigned char *)pCurrentTrackedObjectTable;
|
|
|
1492 |
5dc: e0 91 60 00 lds r30, 0x0060
|
|
|
1493 |
5e0: f0 91 61 00 lds r31, 0x0061
|
|
|
1494 |
for (i=0; i<MAX_TRACKED_OBJECTS; i++)
|
|
|
1495 |
5e4: 41 2f mov r20, r17
|
|
|
1496 |
{
|
|
|
1497 |
if ( (currColor == *(pTrackedObjectData + COLOR_OFFSET)) &&
|
|
|
1498 |
5e6: 80 81 ld r24, Z
|
|
|
1499 |
5e8: 58 17 cp r21, r24
|
|
|
1500 |
5ea: 51 f5 brne .+84 ; 0x640
|
|
|
1501 |
5ec: 87 81 ldd r24, Z+7 ; 0x07
|
|
|
1502 |
5ee: 81 30 cpi r24, 0x01 ; 1
|
|
|
1503 |
5f0: 39 f5 brne .+78 ; 0x640
|
|
|
1504 |
5f2: 86 81 ldd r24, Z+6 ; 0x06
|
|
|
1505 |
5f4: 28 2f mov r18, r24
|
|
|
1506 |
5f6: 33 27 eor r19, r19
|
|
|
1507 |
5f8: 80 91 77 00 lds r24, 0x0077
|
|
|
1508 |
5fc: 99 27 eor r25, r25
|
|
|
1509 |
5fe: 01 97 sbiw r24, 0x01 ; 1
|
|
|
1510 |
600: 28 17 cp r18, r24
|
|
|
1511 |
602: 39 07 cpc r19, r25
|
|
|
1512 |
604: e9 f4 brne .+58 ; 0x640
|
|
|
1513 |
(*(pTrackedObjectData + VALID_OBJECT_OFFSET) == TRUE) &&
|
|
|
1514 |
(*(pTrackedObjectData + Y_LOWER_RIGHT_OFFSET) == trackedLineCount - 1) )
|
|
|
1515 |
{
|
|
|
1516 |
/* found a color match and the object is valid...check to see if there is
|
|
|
1517 |
connectedness */
|
|
|
1518 |
lastLineXStart = *(pTrackedObjectData + LAST_LINE_X_START_OFFSET);
|
|
|
1519 |
606: 81 81 ldd r24, Z+1 ; 0x01
|
|
|
1520 |
lastLineXFinish = *(pTrackedObjectData + LAST_LINE_X_FINISH_OFFSET);
|
|
|
1521 |
608: 92 81 ldd r25, Z+2 ; 0x02
|
|
|
1522 |
|
|
|
1523 |
/* Check for the 5 following types of line connectedness:
|
|
|
1524 |
---------------------
|
|
|
1525 |
| |
|
|
|
1526 |
---------------------
|
|
|
1527 |
-------------------------
|
|
|
1528 |
| |
|
|
|
1529 |
------------------------- */
|
|
|
1530 |
if ( ( (currPixelRunStart >= lastLineXStart) &&
|
|
|
1531 |
60a: c8 17 cp r28, r24
|
|
|
1532 |
60c: 10 f0 brcs .+4 ; 0x612
|
|
|
1533 |
60e: 9c 17 cp r25, r28
|
|
|
1534 |
610: 40 f4 brcc .+16 ; 0x622
|
|
|
1535 |
612: 68 17 cp r22, r24
|
|
|
1536 |
614: 10 f0 brcs .+4 ; 0x61a
|
|
|
1537 |
616: 96 17 cp r25, r22
|
|
|
1538 |
618: 20 f4 brcc .+8 ; 0x622
|
|
|
1539 |
61a: 8c 17 cp r24, r28
|
|
|
1540 |
61c: 88 f0 brcs .+34 ; 0x640
|
|
|
1541 |
61e: 69 17 cp r22, r25
|
|
|
1542 |
620: 78 f0 brcs .+30 ; 0x640
|
|
|
1543 |
(currPixelRunStart <= lastLineXFinish) ) ||
|
|
|
1544 |
|
|
|
1545 |
/* ---------------------
|
|
|
1546 |
| |
|
|
|
1547 |
---------------------
|
|
|
1548 |
-------------------
|
|
|
1549 |
| |
|
|
|
1550 |
-------------------
|
|
|
1551 |
OR
|
|
|
1552 |
------------------------------
|
|
|
1553 |
| |
|
|
|
1554 |
------------------------------
|
|
|
1555 |
---------
|
|
|
1556 |
| |
|
|
|
1557 |
--------- */
|
|
|
1558 |
( (currPixelRunFinish >= lastLineXStart) &&
|
|
|
1559 |
(currPixelRunFinish <= lastLineXFinish) ) ||
|
|
|
1560 |
|
|
|
1561 |
|
|
|
1562 |
/* -------------------------------
|
|
|
1563 |
| |
|
|
|
1564 |
-------------------------------
|
|
|
1565 |
-------------------------------
|
|
|
1566 |
| |
|
|
|
1567 |
-------------------------------
|
|
|
1568 |
OR
|
|
|
1569 |
-------------
|
|
|
1570 |
| |
|
|
|
1571 |
-------------
|
|
|
1572 |
-------------------------------
|
|
|
1573 |
| |
|
|
|
1574 |
------------------------------- */
|
|
|
1575 |
( (currPixelRunStart <= lastLineXStart) &&
|
|
|
1576 |
(currPixelRunFinish >= lastLineXFinish) ) )
|
|
|
1577 |
{
|
|
|
1578 |
/* THERE IS CONNECTEDNESS...update the lastLineXStart and lastLineXFinish
|
|
|
1579 |
data pointed to by pTrackedObjectData */
|
|
|
1580 |
*(pTrackedObjectData + LAST_LINE_X_START_OFFSET) = currPixelRunStart;
|
|
|
1581 |
622: c1 83 std Z+1, r28 ; 0x01
|
|
|
1582 |
*(pTrackedObjectData + LAST_LINE_X_FINISH_OFFSET) = currPixelRunFinish;
|
|
|
1583 |
624: 62 83 std Z+2, r22 ; 0x02
|
|
|
1584 |
|
|
|
1585 |
/* check if the bounding box needs to be updated */
|
|
|
1586 |
if (*(pTrackedObjectData + X_UPPER_LEFT_OFFSET) > currPixelRunStart)
|
|
|
1587 |
626: 83 81 ldd r24, Z+3 ; 0x03
|
|
|
1588 |
628: c8 17 cp r28, r24
|
|
|
1589 |
62a: 08 f4 brcc .+2 ; 0x62e
|
|
|
1590 |
{
|
|
|
1591 |
/* need to update the bounding box for the upper left point to
|
|
|
1592 |
enclose this new left-most point...we never have to update the
|
|
|
1593 |
upper left Y point, since each scan line we process moves from
|
|
|
1594 |
top to bottom */
|
|
|
1595 |
*(pTrackedObjectData + X_UPPER_LEFT_OFFSET) = currPixelRunStart;
|
|
|
1596 |
62c: c3 83 std Z+3, r28 ; 0x03
|
|
|
1597 |
}
|
|
|
1598 |
|
|
|
1599 |
if ( *(pTrackedObjectData + X_LOWER_RIGHT_OFFSET) < currPixelRunFinish)
|
|
|
1600 |
62e: 85 81 ldd r24, Z+5 ; 0x05
|
|
|
1601 |
630: 86 17 cp r24, r22
|
|
|
1602 |
632: 08 f4 brcc .+2 ; 0x636
|
|
|
1603 |
{
|
|
|
1604 |
/* need to update the bounding box for the lower right X point to
|
|
|
1605 |
enclose this new right-most point */
|
|
|
1606 |
*(pTrackedObjectData + X_LOWER_RIGHT_OFFSET) = currPixelRunFinish;
|
|
|
1607 |
634: 65 83 std Z+5, r22 ; 0x05
|
|
|
1608 |
}
|
|
|
1609 |
|
|
|
1610 |
/* the lower right 'y' point always gets updated when connectedness is found */
|
|
|
1611 |
*(pTrackedObjectData + Y_LOWER_RIGHT_OFFSET) = trackedLineCount;
|
|
|
1612 |
636: 80 91 77 00 lds r24, 0x0077
|
|
|
1613 |
63a: 86 83 std Z+6, r24 ; 0x06
|
|
|
1614 |
|
|
|
1615 |
/* set a flag indicating that that color run is part of another
|
|
|
1616 |
object and thus doesn't need to be added as a new entry into the
|
|
|
1617 |
tracking table */
|
|
|
1618 |
colorConnected = TRUE;
|
|
|
1619 |
63c: 11 e0 ldi r17, 0x01 ; 1
|
|
|
1620 |
break;
|
|
|
1621 |
63e: 04 c0 rjmp .+8 ; 0x648
|
|
|
1622 |
}
|
|
|
1623 |
}
|
|
|
1624 |
|
|
|
1625 |
/* go to the next object */
|
|
|
1626 |
pTrackedObjectData += SIZE_OF_TRACKED_OBJECT;
|
|
|
1627 |
640: 38 96 adiw r30, 0x08 ; 8
|
|
|
1628 |
642: 4f 5f subi r20, 0xFF ; 255
|
|
|
1629 |
644: 48 30 cpi r20, 0x08 ; 8
|
|
|
1630 |
646: 78 f2 brcs .-98 ; 0x5e6
|
|
|
1631 |
}
|
|
|
1632 |
|
|
|
1633 |
if (colorConnected == FALSE)
|
|
|
1634 |
648: 11 23 and r17, r17
|
|
|
1635 |
64a: 11 f5 brne .+68 ; 0x690
|
|
|
1636 |
{
|
|
|
1637 |
/* a new entry needs to be made to the tracking table, since we have
|
|
|
1638 |
a run-length with a color, and it isn't connected to anything...but we
|
|
|
1639 |
can only do this if there is space left in the trackedObject table */
|
|
|
1640 |
if (numCurrTrackedObjects < MAX_TRACKED_OBJECTS)
|
|
|
1641 |
64c: 80 91 75 00 lds r24, 0x0075
|
|
|
1642 |
650: 88 30 cpi r24, 0x08 ; 8
|
|
|
1643 |
652: f0 f4 brcc .+60 ; 0x690
|
|
|
1644 |
{
|
|
|
1645 |
/* space is available...add the object...but first we need to find an
|
|
|
1646 |
invalid object in the object tracking table */
|
|
|
1647 |
pTrackedObjectData = (unsigned char *)pCurrentTrackedObjectTable;
|
|
|
1648 |
654: e0 91 60 00 lds r30, 0x0060
|
|
|
1649 |
658: f0 91 61 00 lds r31, 0x0061
|
|
|
1650 |
for (i=0; i<MAX_TRACKED_OBJECTS; i++)
|
|
|
1651 |
65c: 41 2f mov r20, r17
|
|
|
1652 |
{
|
|
|
1653 |
if ( *(pTrackedObjectData + VALID_OBJECT_OFFSET) == FALSE) break;
|
|
|
1654 |
65e: 87 81 ldd r24, Z+7 ; 0x07
|
|
|
1655 |
660: 88 23 and r24, r24
|
|
|
1656 |
662: 21 f0 breq .+8 ; 0x66c
|
|
|
1657 |
|
|
|
1658 |
/* if we haven't broken above, then the object must have been valid...
|
|
|
1659 |
go ahead and move the pointer to the next object to check it */
|
|
|
1660 |
pTrackedObjectData += SIZE_OF_TRACKED_OBJECT;
|
|
|
1661 |
664: 38 96 adiw r30, 0x08 ; 8
|
|
|
1662 |
666: 4f 5f subi r20, 0xFF ; 255
|
|
|
1663 |
668: 48 30 cpi r20, 0x08 ; 8
|
|
|
1664 |
66a: c8 f3 brcs .-14 ; 0x65e
|
|
|
1665 |
}
|
|
|
1666 |
|
|
|
1667 |
|
|
|
1668 |
/* now that we have a pointer to the tracked object to be updated, update all
|
|
|
1669 |
the fields */
|
|
|
1670 |
*(pTrackedObjectData + COLOR_OFFSET) = currColor; /* color */
|
|
|
1671 |
66c: 50 83 st Z, r21
|
|
|
1672 |
*(pTrackedObjectData + LAST_LINE_X_START_OFFSET) = currPixelRunStart; /* lastLineXStart */
|
|
|
1673 |
66e: c1 83 std Z+1, r28 ; 0x01
|
|
|
1674 |
*(pTrackedObjectData + LAST_LINE_X_FINISH_OFFSET) = currPixelRunFinish; /* lastLineXFinish */
|
|
|
1675 |
670: 62 83 std Z+2, r22 ; 0x02
|
|
|
1676 |
*(pTrackedObjectData + X_UPPER_LEFT_OFFSET) = currPixelRunStart; /* x_upperLeft */
|
|
|
1677 |
672: c3 83 std Z+3, r28 ; 0x03
|
|
|
1678 |
*(pTrackedObjectData + Y_UPPER_LEFT_OFFSET) = trackedLineCount; /* y_upperLeft */
|
|
|
1679 |
674: 80 91 77 00 lds r24, 0x0077
|
|
|
1680 |
678: 84 83 std Z+4, r24 ; 0x04
|
|
|
1681 |
*(pTrackedObjectData + X_LOWER_RIGHT_OFFSET) = currPixelRunFinish; /* x_lowerRight */
|
|
|
1682 |
67a: 65 83 std Z+5, r22 ; 0x05
|
|
|
1683 |
*(pTrackedObjectData + Y_LOWER_RIGHT_OFFSET) = trackedLineCount; /* y_lowerRight */
|
|
|
1684 |
67c: 80 91 77 00 lds r24, 0x0077
|
|
|
1685 |
680: 86 83 std Z+6, r24 ; 0x06
|
|
|
1686 |
*(pTrackedObjectData + VALID_OBJECT_OFFSET) = TRUE; /* objectValid flag */
|
|
|
1687 |
682: 81 e0 ldi r24, 0x01 ; 1
|
|
|
1688 |
684: 87 83 std Z+7, r24 ; 0x07
|
|
|
1689 |
|
|
|
1690 |
numCurrTrackedObjects++;
|
|
|
1691 |
686: 80 91 75 00 lds r24, 0x0075
|
|
|
1692 |
68a: 8f 5f subi r24, 0xFF ; 255
|
|
|
1693 |
68c: 80 93 75 00 sts 0x0075, r24
|
|
|
1694 |
}
|
|
|
1695 |
}
|
|
|
1696 |
|
|
|
1697 |
/* move the pointer to the beginning of the next tracked object */
|
|
|
1698 |
pTrackedObjectData += SIZE_OF_TRACKED_OBJECT;
|
|
|
1699 |
}
|
|
|
1700 |
} while(currPixelRunFinish < ACTUAL_NUM_PIXELS_IN_A_LINE);
|
|
|
1701 |
690: 60 3b cpi r22, 0xB0 ; 176
|
|
|
1702 |
692: 08 f4 brcc .+2 ; 0x696
|
|
|
1703 |
694: 98 cf rjmp .-208 ; 0x5c6
|
|
|
1704 |
}
|
|
|
1705 |
696: cf 91 pop r28
|
|
|
1706 |
698: 1f 91 pop r17
|
|
|
1707 |
69a: 08 95 ret
|
|
|
1708 |
|
|
|
1709 |
0000069c <UIMgr_init>:
|
|
|
1710 |
Outputs: none
|
|
|
1711 |
***********************************************************/
|
|
|
1712 |
void UIMgr_init(void)
|
|
|
1713 |
{
|
|
|
1714 |
memset(asciiTokenBuffer,0x00,MAX_TOKEN_LENGTH+1);
|
|
|
1715 |
69c: 10 92 bf 00 sts 0x00BF, r1
|
|
|
1716 |
6a0: 10 92 c0 00 sts 0x00C0, r1
|
|
|
1717 |
6a4: 10 92 c1 00 sts 0x00C1, r1
|
|
|
1718 |
6a8: 10 92 c2 00 sts 0x00C2, r1
|
|
|
1719 |
memset(tokenBuffer,0x00,MAX_TOKEN_COUNT);
|
|
|
1720 |
6ac: 80 e4 ldi r24, 0x40 ; 64
|
|
|
1721 |
6ae: e3 ec ldi r30, 0xC3 ; 195
|
|
|
1722 |
6b0: f0 e0 ldi r31, 0x00 ; 0
|
|
|
1723 |
6b2: 11 92 st Z+, r1
|
|
|
1724 |
6b4: 8a 95 dec r24
|
|
|
1725 |
6b6: e9 f7 brne .-6 ; 0x6b2
|
|
|
1726 |
memset(UIMgr_txFifo,0x00,UI_MGR_TX_FIFO_SIZE);
|
|
|
1727 |
6b8: 80 e4 ldi r24, 0x40 ; 64
|
|
|
1728 |
6ba: e4 e9 ldi r30, 0x94 ; 148
|
|
|
1729 |
6bc: f2 e0 ldi r31, 0x02 ; 2
|
|
|
1730 |
6be: 11 92 st Z+, r1
|
|
|
1731 |
6c0: 8a 95 dec r24
|
|
|
1732 |
6c2: e9 f7 brne .-6 ; 0x6be
|
|
|
1733 |
memset(UIMgr_rxFifo,0x00,UI_MGR_RX_FIFO_SIZE);
|
|
|
1734 |
6c4: 80 e2 ldi r24, 0x20 ; 32
|
|
|
1735 |
6c6: e4 e7 ldi r30, 0x74 ; 116
|
|
|
1736 |
6c8: f2 e0 ldi r31, 0x02 ; 2
|
|
|
1737 |
6ca: 11 92 st Z+, r1
|
|
|
1738 |
6cc: 8a 95 dec r24
|
|
|
1739 |
6ce: e9 f7 brne .-6 ; 0x6ca
|
|
|
1740 |
}
|
|
|
1741 |
6d0: 08 95 ret
|
|
|
1742 |
|
|
|
1743 |
000006d2 <UIMgr_dispatchEvent>:
|
|
|
1744 |
|
|
|
1745 |
/***********************************************************
|
|
|
1746 |
Function Name: UIMgr_dispatchEvent
|
|
|
1747 |
Function Description: This function is responsible for
|
|
|
1748 |
processing events that pertain to the UIMgr.
|
|
|
1749 |
Inputs: event - the generated event
|
|
|
1750 |
Outputs: none
|
|
|
1751 |
***********************************************************/
|
|
|
1752 |
void UIMgr_dispatchEvent(unsigned char event)
|
|
|
1753 |
{
|
|
|
1754 |
switch(event)
|
|
|
1755 |
6d2: 99 27 eor r25, r25
|
|
|
1756 |
6d4: 80 31 cpi r24, 0x10 ; 16
|
|
|
1757 |
6d6: 91 05 cpc r25, r1
|
|
|
1758 |
6d8: 51 f0 breq .+20 ; 0x6ee
|
|
|
1759 |
6da: 81 31 cpi r24, 0x11 ; 17
|
|
|
1760 |
6dc: 91 05 cpc r25, r1
|
|
|
1761 |
6de: 1c f4 brge .+6 ; 0x6e6
|
|
|
1762 |
6e0: 01 97 sbiw r24, 0x01 ; 1
|
|
|
1763 |
6e2: 39 f0 breq .+14 ; 0x6f2
|
|
|
1764 |
{
|
|
|
1765 |
case EV_ACQUIRE_LINE_COMPLETE:
|
|
|
1766 |
UIMgr_transmitPendingData();
|
|
|
1767 |
break;
|
|
|
1768 |
|
|
|
1769 |
case EV_SERIAL_DATA_RECEIVED:
|
|
|
1770 |
UIMgr_processReceivedData();
|
|
|
1771 |
break;
|
|
|
1772 |
|
|
|
1773 |
case EV_SERIAL_DATA_PENDING_TX:
|
|
|
1774 |
UIMgr_flushTxBuffer();
|
|
|
1775 |
break;
|
|
|
1776 |
}
|
|
|
1777 |
}
|
|
|
1778 |
6e4: 08 95 ret
|
|
|
1779 |
6e6: 80 39 cpi r24, 0x90 ; 144
|
|
|
1780 |
6e8: 91 05 cpc r25, r1
|
|
|
1781 |
6ea: 29 f0 breq .+10 ; 0x6f6
|
|
|
1782 |
6ec: 08 95 ret
|
|
|
1783 |
6ee: 06 d0 rcall .+12 ; 0x6fc
|
|
|
1784 |
6f0: 08 95 ret
|
|
|
1785 |
6f2: 0e d0 rcall .+28 ; 0x710
|
|
|
1786 |
6f4: 08 95 ret
|
|
|
1787 |
6f6: e6 d1 rcall .+972 ; 0xac4
|
|
|
1788 |
6f8: 08 95 ret
|
|
|
1789 |
6fa: 08 95 ret
|
|
|
1790 |
|
|
|
1791 |
000006fc <UIMgr_transmitPendingData>:
|
|
|
1792 |
/***********************************************************
|
|
|
1793 |
Function Name: UIMgr_transmitPendingData
|
|
|
1794 |
Function Description: This function is responsible for
|
|
|
1795 |
transmitting a single byte of data if data is waiting
|
|
|
1796 |
to be sent. Otherwise, if nothing is waiting, the
|
|
|
1797 |
function just returns.
|
|
|
1798 |
Inputs: none
|
|
|
1799 |
Outputs: none
|
|
|
1800 |
***********************************************************/
|
|
|
1801 |
void UIMgr_transmitPendingData(void)
|
|
|
1802 |
{
|
|
|
1803 |
if (IS_DATA_IN_TX_FIFO() == TRUE)
|
|
|
1804 |
6fc: 90 91 ba 00 lds r25, 0x00BA
|
|
|
1805 |
700: 80 91 bb 00 lds r24, 0x00BB
|
|
|
1806 |
704: 98 17 cp r25, r24
|
|
|
1807 |
706: 11 f0 breq .+4 ; 0x70c
|
|
|
1808 |
{
|
|
|
1809 |
/* data is waiting...send a single byte */
|
|
|
1810 |
UartInt_txByte( UIMgr_readTxFifo() );
|
|
|
1811 |
708: fe d1 rcall .+1020 ; 0xb06
|
|
|
1812 |
70a: 2a d2 rcall .+1108 ; 0xb60
|
|
|
1813 |
}
|
|
|
1814 |
}
|
|
|
1815 |
70c: 08 95 ret
|
|
|
1816 |
70e: 08 95 ret
|
|
|
1817 |
|
|
|
1818 |
00000710 <UIMgr_processReceivedData>:
|
|
|
1819 |
/***********************************************************
|
|
|
1820 |
Function Name: UIMgr_processReceivedData
|
|
|
1821 |
Function Description: This function is responsible for
|
|
|
1822 |
parsing any serial data waiting in the rx fifo
|
|
|
1823 |
Inputs: none
|
|
|
1824 |
Outputs: none
|
|
|
1825 |
***********************************************************/
|
|
|
1826 |
void UIMgr_processReceivedData(void)
|
|
|
1827 |
{
|
|
|
1828 |
710: cf 93 push r28
|
|
|
1829 |
unsigned char tmpData = 0;
|
|
|
1830 |
|
|
|
1831 |
/* still need to add a mechanism to handle token counts
|
|
|
1832 |
that are excessive!!! FIX ME!!! */
|
|
|
1833 |
|
|
|
1834 |
while(IS_DATA_IN_RX_FIFO() == TRUE)
|
|
|
1835 |
712: 90 91 b8 00 lds r25, 0x00B8
|
|
|
1836 |
716: 80 91 b9 00 lds r24, 0x00B9
|
|
|
1837 |
71a: 98 17 cp r25, r24
|
|
|
1838 |
71c: 09 f4 brne .+2 ; 0x720
|
|
|
1839 |
71e: 6f c0 rjmp .+222 ; 0x7fe
|
|
|
1840 |
720: c9 e0 ldi r28, 0x09 ; 9
|
|
|
1841 |
{
|
|
|
1842 |
tmpData = UIMgr_readRxFifo();
|
|
|
1843 |
722: df d1 rcall .+958 ; 0xae2
|
|
|
1844 |
724: 38 2f mov r19, r24
|
|
|
1845 |
if (tmpData == '\r')
|
|
|
1846 |
726: 8d 30 cpi r24, 0x0D ; 13
|
|
|
1847 |
728: 29 f5 brne .+74 ; 0x774
|
|
|
1848 |
{
|
|
|
1849 |
/* we have reached a token separator */
|
|
|
1850 |
if (tokenCount == 0)
|
|
|
1851 |
72a: 80 91 be 00 lds r24, 0x00BE
|
|
|
1852 |
72e: 88 23 and r24, r24
|
|
|
1853 |
730: 11 f4 brne .+4 ; 0x736
|
|
|
1854 |
{
|
|
|
1855 |
/* convert the command */
|
|
|
1856 |
UIMgr_convertTokenToCmd();
|
|
|
1857 |
732: 2c d1 rcall .+600 ; 0x98c
|
|
|
1858 |
734: 06 c0 rjmp .+12 ; 0x742
|
|
|
1859 |
}
|
|
|
1860 |
else
|
|
|
1861 |
{
|
|
|
1862 |
/* convert a value */
|
|
|
1863 |
UIMgr_convertTokenToValue();
|
|
|
1864 |
736: 02 d1 rcall .+516 ; 0x93c
|
|
|
1865 |
tokenCount++;
|
|
|
1866 |
738: 80 91 be 00 lds r24, 0x00BE
|
|
|
1867 |
73c: 8f 5f subi r24, 0xFF ; 255
|
|
|
1868 |
73e: 80 93 be 00 sts 0x00BE, r24
|
|
|
1869 |
}
|
|
|
1870 |
/* either way, it is time to try to process the received
|
|
|
1871 |
token list since we have reached the end of the cmd. */
|
|
|
1872 |
Utility_delay(100);
|
|
|
1873 |
742: 84 e6 ldi r24, 0x64 ; 100
|
|
|
1874 |
744: 90 e0 ldi r25, 0x00 ; 0
|
|
|
1875 |
746: 7f d3 rcall .+1790 ; 0xe46
|
|
|
1876 |
if (receivedCmd == invalidCmd ||
|
|
|
1877 |
748: 80 91 62 00 lds r24, 0x0062
|
|
|
1878 |
74c: 88 50 subi r24, 0x08 ; 8
|
|
|
1879 |
74e: 82 30 cpi r24, 0x02 ; 2
|
|
|
1880 |
750: 20 f4 brcc .+8 ; 0x75a
|
|
|
1881 |
receivedCmd == noCmd )
|
|
|
1882 |
{
|
|
|
1883 |
UIMgr_sendNck();
|
|
|
1884 |
752: 84 d1 rcall .+776 ; 0xa5c
|
|
|
1885 |
PUBLISH_EVENT(EV_SERIAL_DATA_PENDING_TX);
|
|
|
1886 |
754: 80 e9 ldi r24, 0x90 ; 144
|
|
|
1887 |
756: 7d dd rcall .-1286 ; 0x252
|
|
|
1888 |
758: 04 c0 rjmp .+8 ; 0x762
|
|
|
1889 |
}
|
|
|
1890 |
else
|
|
|
1891 |
{
|
|
|
1892 |
UIMgr_sendAck();
|
|
|
1893 |
75a: 77 d1 rcall .+750 ; 0xa4a
|
|
|
1894 |
/* publish the serial data pending event, so it
|
|
|
1895 |
will push the ACK out before we execute the cmd */
|
|
|
1896 |
PUBLISH_EVENT(EV_SERIAL_DATA_PENDING_TX);
|
|
|
1897 |
75c: 80 e9 ldi r24, 0x90 ; 144
|
|
|
1898 |
75e: 79 dd rcall .-1294 ; 0x252
|
|
|
1899 |
UIMgr_executeCmd();
|
|
|
1900 |
760: 51 d0 rcall .+162 ; 0x804
|
|
|
1901 |
}
|
|
|
1902 |
|
|
|
1903 |
/* reset any necessary data */
|
|
|
1904 |
tokenCount = 0;
|
|
|
1905 |
762: 10 92 be 00 sts 0x00BE, r1
|
|
|
1906 |
memset(tokenBuffer,0x00,MAX_TOKEN_COUNT);
|
|
|
1907 |
766: 80 e4 ldi r24, 0x40 ; 64
|
|
|
1908 |
768: e3 ec ldi r30, 0xC3 ; 195
|
|
|
1909 |
76a: f0 e0 ldi r31, 0x00 ; 0
|
|
|
1910 |
76c: 11 92 st Z+, r1
|
|
|
1911 |
76e: 8a 95 dec r24
|
|
|
1912 |
770: e9 f7 brne .-6 ; 0x76c
|
|
|
1913 |
772: 3e c0 rjmp .+124 ; 0x7f0
|
|
|
1914 |
}
|
|
|
1915 |
else if (tmpData == ' ') /* space char */
|
|
|
1916 |
774: 80 32 cpi r24, 0x20 ; 32
|
|
|
1917 |
776: d9 f4 brne .+54 ; 0x7ae
|
|
|
1918 |
{
|
|
|
1919 |
/* the end of a token has been reached */
|
|
|
1920 |
if (tokenCount == 0)
|
|
|
1921 |
778: 80 91 be 00 lds r24, 0x00BE
|
|
|
1922 |
77c: 88 23 and r24, r24
|
|
|
1923 |
77e: 11 f4 brne .+4 ; 0x784
|
|
|
1924 |
{
|
|
|
1925 |
UIMgr_convertTokenToCmd();
|
|
|
1926 |
780: 05 d1 rcall .+522 ; 0x98c
|
|
|
1927 |
tokenCount++; /* check this...why is this being incremented here??? This
|
|
|
1928 |
782: 0f c0 rjmp .+30 ; 0x7a2
|
|
|
1929 |
means we have received a token, with tokenCount == 0, which means it is a
|
|
|
1930 |
command...why is this contributing to tokenCount?
|
|
|
1931 |
This might cause the set color map command to include too much data, since
|
|
|
1932 |
it sets the color map based on tokenCount...CHECK*/
|
|
|
1933 |
}
|
|
|
1934 |
else
|
|
|
1935 |
{
|
|
|
1936 |
/* check to see if this token is going to push
|
|
|
1937 |
us over the limit...if so, abort the transaction */
|
|
|
1938 |
if (tokenCount+1 >= MAX_TOKEN_COUNT)
|
|
|
1939 |
784: 80 91 be 00 lds r24, 0x00BE
|
|
|
1940 |
788: 99 27 eor r25, r25
|
|
|
1941 |
78a: 01 96 adiw r24, 0x01 ; 1
|
|
|
1942 |
78c: 80 34 cpi r24, 0x40 ; 64
|
|
|
1943 |
78e: 91 05 cpc r25, r1
|
|
|
1944 |
790: 3c f0 brlt .+14 ; 0x7a0
|
|
|
1945 |
{
|
|
|
1946 |
/* we received too many tokens, and
|
|
|
1947 |
need to NCK this request, since its too
|
|
|
1948 |
large...reset everything...*/
|
|
|
1949 |
charCount=0;
|
|
|
1950 |
792: 10 92 bc 00 sts 0x00BC, r1
|
|
|
1951 |
charIndex=0;
|
|
|
1952 |
796: 10 92 bd 00 sts 0x00BD, r1
|
|
|
1953 |
tokenCount=0;
|
|
|
1954 |
79a: 10 92 be 00 sts 0x00BE, r1
|
|
|
1955 |
receivedCmd = invalidCmd;
|
|
|
1956 |
79e: 26 c0 rjmp .+76 ; 0x7ec
|
|
|
1957 |
}
|
|
|
1958 |
else
|
|
|
1959 |
{
|
|
|
1960 |
/* tokenCount is still in range...*/
|
|
|
1961 |
UIMgr_convertTokenToValue();
|
|
|
1962 |
7a0: cd d0 rcall .+410 ; 0x93c
|
|
|
1963 |
tokenCount++;
|
|
|
1964 |
7a2: 80 91 be 00 lds r24, 0x00BE
|
|
|
1965 |
7a6: 8f 5f subi r24, 0xFF ; 255
|
|
|
1966 |
7a8: 80 93 be 00 sts 0x00BE, r24
|
|
|
1967 |
7ac: 21 c0 rjmp .+66 ; 0x7f0
|
|
|
1968 |
}
|
|
|
1969 |
}
|
|
|
1970 |
}
|
|
|
1971 |
else if ( (tmpData >= 'A' && tmpData <= 'Z') ||
|
|
|
1972 |
7ae: 81 54 subi r24, 0x41 ; 65
|
|
|
1973 |
7b0: 8a 31 cpi r24, 0x1A ; 26
|
|
|
1974 |
7b2: 18 f0 brcs .+6 ; 0x7ba
|
|
|
1975 |
7b4: 8f 5e subi r24, 0xEF ; 239
|
|
|
1976 |
7b6: 8a 30 cpi r24, 0x0A ; 10
|
|
|
1977 |
7b8: c8 f4 brcc .+50 ; 0x7ec
|
|
|
1978 |
(tmpData >= '0' && tmpData <= '9') )
|
|
|
1979 |
{
|
|
|
1980 |
/* a valid range of token was received */
|
|
|
1981 |
asciiTokenBuffer[charIndex] = tmpData;
|
|
|
1982 |
7ba: 20 91 bd 00 lds r18, 0x00BD
|
|
|
1983 |
7be: 82 2f mov r24, r18
|
|
|
1984 |
7c0: 99 27 eor r25, r25
|
|
|
1985 |
7c2: fc 01 movw r30, r24
|
|
|
1986 |
7c4: e1 54 subi r30, 0x41 ; 65
|
|
|
1987 |
7c6: ff 4f sbci r31, 0xFF ; 255
|
|
|
1988 |
7c8: 30 83 st Z, r19
|
|
|
1989 |
charCount++;
|
|
|
1990 |
7ca: 80 91 bc 00 lds r24, 0x00BC
|
|
|
1991 |
7ce: 98 2f mov r25, r24
|
|
|
1992 |
7d0: 9f 5f subi r25, 0xFF ; 255
|
|
|
1993 |
7d2: 90 93 bc 00 sts 0x00BC, r25
|
|
|
1994 |
charIndex++;
|
|
|
1995 |
7d6: 82 2f mov r24, r18
|
|
|
1996 |
7d8: 8f 5f subi r24, 0xFF ; 255
|
|
|
1997 |
7da: 80 93 bd 00 sts 0x00BD, r24
|
|
|
1998 |
if (charCount > MAX_TOKEN_LENGTH)
|
|
|
1999 |
7de: 94 30 cpi r25, 0x04 ; 4
|
|
|
2000 |
7e0: 38 f0 brcs .+14 ; 0x7f0
|
|
|
2001 |
{
|
|
|
2002 |
/* we have received a token that cannot be handled...
|
|
|
2003 |
set the received cmd to an invalid cmd, and wait
|
|
|
2004 |
for the \r to process it */
|
|
|
2005 |
receivedCmd = invalidCmd;
|
|
|
2006 |
7e2: c0 93 62 00 sts 0x0062, r28
|
|
|
2007 |
charIndex = 0; /* ...so we won't overwrite memory */
|
|
|
2008 |
7e6: 10 92 bd 00 sts 0x00BD, r1
|
|
|
2009 |
7ea: 02 c0 rjmp .+4 ; 0x7f0
|
|
|
2010 |
}
|
|
|
2011 |
}
|
|
|
2012 |
else
|
|
|
2013 |
{
|
|
|
2014 |
/* an invalid character was received */
|
|
|
2015 |
receivedCmd = invalidCmd;
|
|
|
2016 |
7ec: c0 93 62 00 sts 0x0062, r28
|
|
|
2017 |
7f0: 90 91 b8 00 lds r25, 0x00B8
|
|
|
2018 |
7f4: 80 91 b9 00 lds r24, 0x00B9
|
|
|
2019 |
7f8: 98 17 cp r25, r24
|
|
|
2020 |
7fa: 09 f0 breq .+2 ; 0x7fe
|
|
|
2021 |
7fc: 92 cf rjmp .-220 ; 0x722
|
|
|
2022 |
}
|
|
|
2023 |
} /* end while */
|
|
|
2024 |
|
|
|
2025 |
asm volatile("clt"::); /* clear out the T flag in case it wasn't
|
|
|
2026 |
7fe: e8 94 clt
|
|
|
2027 |
cleared already */
|
|
|
2028 |
}
|
|
|
2029 |
800: cf 91 pop r28
|
|
|
2030 |
802: 08 95 ret
|
|
|
2031 |
|
|
|
2032 |
00000804 <UIMgr_executeCmd>:
|
|
|
2033 |
|
|
|
2034 |
/***********************************************************
|
|
|
2035 |
Function Name: UIMgr_executeCmd
|
|
|
2036 |
Function Description: This function is responsible for
|
|
|
2037 |
executing whatever cmd is stored in the receivedCmd
|
|
|
2038 |
object.
|
|
|
2039 |
Inputs: none
|
|
|
2040 |
Outputs: none
|
|
|
2041 |
***********************************************************/
|
|
|
2042 |
static void UIMgr_executeCmd(void)
|
|
|
2043 |
{
|
|
|
2044 |
804: df 92 push r13
|
|
|
2045 |
806: ef 92 push r14
|
|
|
2046 |
808: ff 92 push r15
|
|
|
2047 |
80a: 0f 93 push r16
|
|
|
2048 |
80c: 1f 93 push r17
|
|
|
2049 |
80e: cf 93 push r28
|
|
|
2050 |
810: df 93 push r29
|
|
|
2051 |
unsigned char i,eepromData, num_writes=0;
|
|
|
2052 |
812: ee 24 eor r14, r14
|
|
|
2053 |
unsigned char *pData;
|
|
|
2054 |
unsigned char eeprom_write_succeeded = FALSE;
|
|
|
2055 |
#if DEBUG_COLOR_MAP
|
|
|
2056 |
unsigned char asciiBuffer[5];
|
|
|
2057 |
#endif
|
|
|
2058 |
|
|
|
2059 |
if (receivedCmd == pingCmd)
|
|
|
2060 |
814: 80 91 62 00 lds r24, 0x0062
|
|
|
2061 |
818: 81 30 cpi r24, 0x01 ; 1
|
|
|
2062 |
81a: 09 f4 brne .+2 ; 0x81e
|
|
|
2063 |
81c: 87 c0 rjmp .+270 ; 0x92c
|
|
|
2064 |
{
|
|
|
2065 |
}
|
|
|
2066 |
else if (receivedCmd == getVersionCmd)
|
|
|
2067 |
81e: 88 23 and r24, r24
|
|
|
2068 |
820: 69 f4 brne .+26 ; 0x83c
|
|
|
2069 |
{
|
|
|
2070 |
pData = AVRcamVersion;
|
|
|
2071 |
822: c3 e6 ldi r28, 0x63 ; 99
|
|
|
2072 |
824: d0 e0 ldi r29, 0x00 ; 0
|
|
|
2073 |
while(*pData != 0)
|
|
|
2074 |
826: 80 91 63 00 lds r24, 0x0063
|
|
|
2075 |
82a: 88 23 and r24, r24
|
|
|
2076 |
82c: 09 f4 brne .+2 ; 0x830
|
|
|
2077 |
82e: 7e c0 rjmp .+252 ; 0x92c
|
|
|
2078 |
{
|
|
|
2079 |
UIMgr_writeTxFifo(*pData++);
|
|
|
2080 |
830: 89 91 ld r24, Y+
|
|
|
2081 |
832: 7b d1 rcall .+758 ; 0xb2a
|
|
|
2082 |
834: 88 81 ld r24, Y
|
|
|
2083 |
836: 88 23 and r24, r24
|
|
|
2084 |
838: d9 f7 brne .-10 ; 0x830
|
|
|
2085 |
83a: 78 c0 rjmp .+240 ; 0x92c
|
|
|
2086 |
}
|
|
|
2087 |
}
|
|
|
2088 |
else if (receivedCmd == resetCameraCmd)
|
|
|
2089 |
83c: 80 91 62 00 lds r24, 0x0062
|
|
|
2090 |
840: 87 30 cpi r24, 0x07 ; 7
|
|
|
2091 |
842: 11 f4 brne .+4 ; 0x848
|
|
|
2092 |
{
|
|
|
2093 |
CamInt_resetCam();
|
|
|
2094 |
844: 8b dc rcall .-1770 ; 0x15c
|
|
|
2095 |
846: 72 c0 rjmp .+228 ; 0x92c
|
|
|
2096 |
}
|
|
|
2097 |
else if (receivedCmd == dumpFrameCmd)
|
|
|
2098 |
848: 80 91 62 00 lds r24, 0x0062
|
|
|
2099 |
84c: 83 30 cpi r24, 0x03 ; 3
|
|
|
2100 |
84e: 29 f4 brne .+10 ; 0x85a
|
|
|
2101 |
{
|
|
|
2102 |
/* publish the event that will indicate that
|
|
|
2103 |
a request has come to dump a frame...this will
|
|
|
2104 |
be received by the FrameMgr, which will begin
|
|
|
2105 |
dumping the frame...a short delay is needed
|
|
|
2106 |
here to keep the Java demo app happy (sometimes
|
|
|
2107 |
it wouldn't be able to receive the serial data
|
|
|
2108 |
as quickly as AVRcam can provide it). */
|
|
|
2109 |
Utility_delay(100);
|
|
|
2110 |
850: 84 e6 ldi r24, 0x64 ; 100
|
|
|
2111 |
852: 90 e0 ldi r25, 0x00 ; 0
|
|
|
2112 |
854: f8 d2 rcall .+1520 ; 0xe46
|
|
|
2113 |
PUBLISH_EVENT(EV_DUMP_FRAME);
|
|
|
2114 |
856: 82 e0 ldi r24, 0x02 ; 2
|
|
|
2115 |
858: 28 c0 rjmp .+80 ; 0x8aa
|
|
|
2116 |
}
|
|
|
2117 |
else if (receivedCmd == setCameraRegsCmd)
|
|
|
2118 |
85a: 80 91 62 00 lds r24, 0x0062
|
|
|
2119 |
85e: 82 30 cpi r24, 0x02 ; 2
|
|
|
2120 |
860: b1 f4 brne .+44 ; 0x88e
|
|
|
2121 |
{
|
|
|
2122 |
/* we need to gather the tokens and
|
|
|
2123 |
build config cmds to be sent to the camera */
|
|
|
2124 |
for (i=1; i<tokenCount; i+=2) /* starts at 1 since first token
|
|
|
2125 |
862: ff 24 eor r15, r15
|
|
|
2126 |
864: f3 94 inc r15
|
|
|
2127 |
866: 80 91 be 00 lds r24, 0x00BE
|
|
|
2128 |
86a: f8 16 cp r15, r24
|
|
|
2129 |
86c: 70 f4 brcc .+28 ; 0x88a
|
|
|
2130 |
is the CR cmd */
|
|
|
2131 |
{
|
|
|
2132 |
CamConfig_setCamReg(tokenBuffer[i],tokenBuffer[i+1]);
|
|
|
2133 |
86e: 8f 2d mov r24, r15
|
|
|
2134 |
870: 99 27 eor r25, r25
|
|
|
2135 |
872: fc 01 movw r30, r24
|
|
|
2136 |
874: ed 53 subi r30, 0x3D ; 61
|
|
|
2137 |
876: ff 4f sbci r31, 0xFF ; 255
|
|
|
2138 |
878: 61 81 ldd r22, Z+1 ; 0x01
|
|
|
2139 |
87a: 80 81 ld r24, Z
|
|
|
2140 |
87c: 85 d2 rcall .+1290 ; 0xd88
|
|
|
2141 |
87e: 82 e0 ldi r24, 0x02 ; 2
|
|
|
2142 |
880: f8 0e add r15, r24
|
|
|
2143 |
882: 80 91 be 00 lds r24, 0x00BE
|
|
|
2144 |
886: f8 16 cp r15, r24
|
|
|
2145 |
888: 90 f3 brcs .-28 ; 0x86e
|
|
|
2146 |
}
|
|
|
2147 |
CamConfig_sendFifoCmds();
|
|
|
2148 |
88a: 83 d2 rcall .+1286 ; 0xd92
|
|
|
2149 |
88c: 4f c0 rjmp .+158 ; 0x92c
|
|
|
2150 |
}
|
|
|
2151 |
else if (receivedCmd == enableTrackingCmd)
|
|
|
2152 |
88e: 80 91 62 00 lds r24, 0x0062
|
|
|
2153 |
892: 84 30 cpi r24, 0x04 ; 4
|
|
|
2154 |
894: 29 f4 brne .+10 ; 0x8a0
|
|
|
2155 |
{
|
|
|
2156 |
/* publish the event...again with a short delay */
|
|
|
2157 |
Utility_delay(100);
|
|
|
2158 |
896: 84 e6 ldi r24, 0x64 ; 100
|
|
|
2159 |
898: 90 e0 ldi r25, 0x00 ; 0
|
|
|
2160 |
89a: d5 d2 rcall .+1450 ; 0xe46
|
|
|
2161 |
PUBLISH_EVENT(EV_ENABLE_TRACKING);
|
|
|
2162 |
89c: 80 e8 ldi r24, 0x80 ; 128
|
|
|
2163 |
89e: 05 c0 rjmp .+10 ; 0x8aa
|
|
|
2164 |
}
|
|
|
2165 |
else if (receivedCmd == disableTrackingCmd)
|
|
|
2166 |
8a0: 80 91 62 00 lds r24, 0x0062
|
|
|
2167 |
8a4: 85 30 cpi r24, 0x05 ; 5
|
|
|
2168 |
8a6: 19 f4 brne .+6 ; 0x8ae
|
|
|
2169 |
{
|
|
|
2170 |
PUBLISH_EVENT(EV_DISABLE_TRACKING);
|
|
|
2171 |
8a8: 81 e8 ldi r24, 0x81 ; 129
|
|
|
2172 |
8aa: d3 dc rcall .-1626 ; 0x252
|
|
|
2173 |
8ac: 3f c0 rjmp .+126 ; 0x92c
|
|
|
2174 |
}
|
|
|
2175 |
else if (receivedCmd == setColorMapCmd)
|
|
|
2176 |
8ae: 80 91 62 00 lds r24, 0x0062
|
|
|
2177 |
8b2: 86 30 cpi r24, 0x06 ; 6
|
|
|
2178 |
8b4: d9 f5 brne .+118 ; 0x92c
|
|
|
2179 |
{
|
|
|
2180 |
/* copy the received tokens into the color map */
|
|
|
2181 |
for (i=0; i<tokenCount; i++)
|
|
|
2182 |
8b6: ff 24 eor r15, r15
|
|
|
2183 |
8b8: 80 91 be 00 lds r24, 0x00BE
|
|
|
2184 |
8bc: f8 16 cp r15, r24
|
|
|
2185 |
8be: b0 f5 brcc .+108 ; 0x92c
|
|
|
2186 |
{
|
|
|
2187 |
colorMap[i] = tokenBuffer[i+1];
|
|
|
2188 |
8c0: 8f 2d mov r24, r15
|
|
|
2189 |
8c2: 99 27 eor r25, r25
|
|
|
2190 |
8c4: 8c 01 movw r16, r24
|
|
|
2191 |
8c6: 00 50 subi r16, 0x00 ; 0
|
|
|
2192 |
8c8: 1d 4f sbci r17, 0xFD ; 253
|
|
|
2193 |
8ca: fc 01 movw r30, r24
|
|
|
2194 |
8cc: ed 53 subi r30, 0x3D ; 61
|
|
|
2195 |
8ce: ff 4f sbci r31, 0xFF ; 255
|
|
|
2196 |
8d0: 21 81 ldd r18, Z+1 ; 0x01
|
|
|
2197 |
8d2: f8 01 movw r30, r16
|
|
|
2198 |
8d4: 20 83 st Z, r18
|
|
|
2199 |
|
|
|
2200 |
/* write each colorMap byte to EEPROM, but only those
|
|
|
2201 |
that changed...this will help reduce wear on the EEPROM */
|
|
|
2202 |
eepromData = eeprom_read_byte( (unsigned char*)(i+1));
|
|
|
2203 |
8d6: 01 96 adiw r24, 0x01 ; 1
|
|
|
2204 |
8d8: b5 d3 rcall .+1898 ; 0x1044
|
|
|
2205 |
8da: 98 2f mov r25, r24
|
|
|
2206 |
if (eepromData != colorMap[i])
|
|
|
2207 |
8dc: f8 01 movw r30, r16
|
|
|
2208 |
8de: 80 81 ld r24, Z
|
|
|
2209 |
8e0: 98 17 cp r25, r24
|
|
|
2210 |
8e2: f9 f0 breq .+62 ; 0x922
|
|
|
2211 |
{
|
|
|
2212 |
/* need to actually perform the write because the
|
|
|
2213 |
data in eeprom is different than the current colorMap */
|
|
|
2214 |
eeprom_write_succeeded = FALSE;
|
|
|
2215 |
8e4: dd 24 eor r13, r13
|
|
|
2216 |
while(eeprom_write_succeeded == FALSE && num_writes < MAX_EEPROM_WRITE_ATTEMPTS)
|
|
|
2217 |
8e6: f2 e0 ldi r31, 0x02 ; 2
|
|
|
2218 |
8e8: fe 15 cp r31, r14
|
|
|
2219 |
8ea: d0 f0 brcs .+52 ; 0x920
|
|
|
2220 |
8ec: 8f 2d mov r24, r15
|
|
|
2221 |
8ee: 99 27 eor r25, r25
|
|
|
2222 |
8f0: 8c 01 movw r16, r24
|
|
|
2223 |
8f2: 00 50 subi r16, 0x00 ; 0
|
|
|
2224 |
8f4: 1d 4f sbci r17, 0xFD ; 253
|
|
|
2225 |
8f6: ec 01 movw r28, r24
|
|
|
2226 |
8f8: 21 96 adiw r28, 0x01 ; 1
|
|
|
2227 |
{
|
|
|
2228 |
eeprom_write_byte((unsigned char*)(i+1),colorMap[i]);
|
|
|
2229 |
8fa: f8 01 movw r30, r16
|
|
|
2230 |
8fc: 60 81 ld r22, Z
|
|
|
2231 |
8fe: ce 01 movw r24, r28
|
|
|
2232 |
900: ba d3 rcall .+1908 ; 0x1076
|
|
|
2233 |
num_writes++;
|
|
|
2234 |
902: e3 94 inc r14
|
|
|
2235 |
eepromData = eeprom_read_byte( (unsigned char*)(i+1));
|
|
|
2236 |
904: ce 01 movw r24, r28
|
|
|
2237 |
906: 9e d3 rcall .+1852 ; 0x1044
|
|
|
2238 |
908: 98 2f mov r25, r24
|
|
|
2239 |
if (eepromData == colorMap[i])
|
|
|
2240 |
90a: f8 01 movw r30, r16
|
|
|
2241 |
90c: 80 81 ld r24, Z
|
|
|
2242 |
90e: 98 17 cp r25, r24
|
|
|
2243 |
910: 11 f4 brne .+4 ; 0x916
|
|
|
2244 |
{
|
|
|
2245 |
eeprom_write_succeeded = TRUE;
|
|
|
2246 |
912: dd 24 eor r13, r13
|
|
|
2247 |
914: d3 94 inc r13
|
|
|
2248 |
916: dd 20 and r13, r13
|
|
|
2249 |
918: 19 f4 brne .+6 ; 0x920
|
|
|
2250 |
91a: f2 e0 ldi r31, 0x02 ; 2
|
|
|
2251 |
91c: fe 15 cp r31, r14
|
|
|
2252 |
91e: 68 f7 brcc .-38 ; 0x8fa
|
|
|
2253 |
}
|
|
|
2254 |
}
|
|
|
2255 |
num_writes = 0;
|
|
|
2256 |
920: ee 24 eor r14, r14
|
|
|
2257 |
922: f3 94 inc r15
|
|
|
2258 |
924: 80 91 be 00 lds r24, 0x00BE
|
|
|
2259 |
928: f8 16 cp r15, r24
|
|
|
2260 |
92a: 50 f2 brcs .-108 ; 0x8c0
|
|
|
2261 |
}
|
|
|
2262 |
}
|
|
|
2263 |
|
|
|
2264 |
#if DEBUG_COLOR_MAP
|
|
|
2265 |
/* for debugging...send out the entire color map */
|
|
|
2266 |
UIMgr_txBuffer("\r\n",2);
|
|
|
2267 |
for (i=0; i<NUM_ELEMENTS_IN_COLOR_MAP; i++)
|
|
|
2268 |
{
|
|
|
2269 |
memset(asciiBuffer,0x00,5);
|
|
|
2270 |
itoa(colorMap[i],asciiBuffer,10);
|
|
|
2271 |
UIMgr_txBuffer(asciiBuffer,3);
|
|
|
2272 |
UIMgr_txBuffer(" ",1);
|
|
|
2273 |
if (i==15 || i == 31)
|
|
|
2274 |
{
|
|
|
2275 |
/* break up the output */
|
|
|
2276 |
UIMgr_txBuffer("\r\n",2);
|
|
|
2277 |
}
|
|
|
2278 |
}
|
|
|
2279 |
#endif
|
|
|
2280 |
}
|
|
|
2281 |
}
|
|
|
2282 |
92c: df 91 pop r29
|
|
|
2283 |
92e: cf 91 pop r28
|
|
|
2284 |
930: 1f 91 pop r17
|
|
|
2285 |
932: 0f 91 pop r16
|
|
|
2286 |
934: ff 90 pop r15
|
|
|
2287 |
936: ef 90 pop r14
|
|
|
2288 |
938: df 90 pop r13
|
|
|
2289 |
93a: 08 95 ret
|
|
|
2290 |
|
|
|
2291 |
0000093c <UIMgr_convertTokenToValue>:
|
|
|
2292 |
|
|
|
2293 |
/***********************************************************
|
|
|
2294 |
Function Name: UIMgr_convertTokenToValue
|
|
|
2295 |
Function Description: This function is responsible for
|
|
|
2296 |
converting a received token to a hex value It will
|
|
|
2297 |
access the asciiTokenBuffer directly, and store the
|
|
|
2298 |
result in the appropriate token buffer.
|
|
|
2299 |
Inputs: none
|
|
|
2300 |
Outputs: none
|
|
|
2301 |
***********************************************************/
|
|
|
2302 |
static void UIMgr_convertTokenToValue(void)
|
|
|
2303 |
{
|
|
|
2304 |
unsigned int newValue;
|
|
|
2305 |
|
|
|
2306 |
newValue = atoi(asciiTokenBuffer);
|
|
|
2307 |
93c: 8f eb ldi r24, 0xBF ; 191
|
|
|
2308 |
93e: 90 e0 ldi r25, 0x00 ; 0
|
|
|
2309 |
940: 55 d3 rcall .+1706 ; 0xfec
|
|
|
2310 |
942: ac 01 movw r20, r24
|
|
|
2311 |
if (newValue > 255)
|
|
|
2312 |
944: 8f 3f cpi r24, 0xFF ; 255
|
|
|
2313 |
946: 91 05 cpc r25, r1
|
|
|
2314 |
948: 71 f0 breq .+28 ; 0x966
|
|
|
2315 |
94a: 68 f0 brcs .+26 ; 0x966
|
|
|
2316 |
{
|
|
|
2317 |
/* the value is too large */
|
|
|
2318 |
receivedCmd = invalidCmd;
|
|
|
2319 |
94c: 89 e0 ldi r24, 0x09 ; 9
|
|
|
2320 |
94e: 80 93 62 00 sts 0x0062, r24
|
|
|
2321 |
tokenBuffer[tokenCount] = 0xFF; /* to indicate an error */
|
|
|
2322 |
952: 20 91 be 00 lds r18, 0x00BE
|
|
|
2323 |
956: 83 ec ldi r24, 0xC3 ; 195
|
|
|
2324 |
958: 90 e0 ldi r25, 0x00 ; 0
|
|
|
2325 |
95a: fc 01 movw r30, r24
|
|
|
2326 |
95c: e2 0f add r30, r18
|
|
|
2327 |
95e: f1 1d adc r31, r1
|
|
|
2328 |
960: 8f ef ldi r24, 0xFF ; 255
|
|
|
2329 |
962: 80 83 st Z, r24
|
|
|
2330 |
964: 08 c0 rjmp .+16 ; 0x976
|
|
|
2331 |
}
|
|
|
2332 |
else
|
|
|
2333 |
{
|
|
|
2334 |
/* copy the value into the tokenBuffer */
|
|
|
2335 |
tokenBuffer[tokenCount] = newValue;
|
|
|
2336 |
966: 80 91 be 00 lds r24, 0x00BE
|
|
|
2337 |
96a: 23 ec ldi r18, 0xC3 ; 195
|
|
|
2338 |
96c: 30 e0 ldi r19, 0x00 ; 0
|
|
|
2339 |
96e: f9 01 movw r30, r18
|
|
|
2340 |
970: e8 0f add r30, r24
|
|
|
2341 |
972: f1 1d adc r31, r1
|
|
|
2342 |
974: 40 83 st Z, r20
|
|
|
2343 |
}
|
|
|
2344 |
memset(asciiTokenBuffer,0x00,MAX_TOKEN_LENGTH);
|
|
|
2345 |
976: 83 e0 ldi r24, 0x03 ; 3
|
|
|
2346 |
978: ef eb ldi r30, 0xBF ; 191
|
|
|
2347 |
97a: f0 e0 ldi r31, 0x00 ; 0
|
|
|
2348 |
97c: 11 92 st Z+, r1
|
|
|
2349 |
97e: 8a 95 dec r24
|
|
|
2350 |
980: e9 f7 brne .-6 ; 0x97c
|
|
|
2351 |
charIndex = 0;
|
|
|
2352 |
982: 10 92 bd 00 sts 0x00BD, r1
|
|
|
2353 |
charCount = 0;
|
|
|
2354 |
986: 10 92 bc 00 sts 0x00BC, r1
|
|
|
2355 |
}
|
|
|
2356 |
98a: 08 95 ret
|
|
|
2357 |
|
|
|
2358 |
0000098c <UIMgr_convertTokenToCmd>:
|
|
|
2359 |
/***********************************************************
|
|
|
2360 |
Function Name: UIMgr_convertTokenToCmd
|
|
|
2361 |
Function Description: This function is responsible for
|
|
|
2362 |
parsing a received 2-character command. It will
|
|
|
2363 |
access the asciiTokenBuffer directly.
|
|
|
2364 |
Inputs: none
|
|
|
2365 |
Outputs: none
|
|
|
2366 |
***********************************************************/
|
|
|
2367 |
static void UIMgr_convertTokenToCmd(void)
|
|
|
2368 |
{
|
|
|
2369 |
if ( (asciiTokenBuffer[0] == 'P') &&
|
|
|
2370 |
98c: 80 91 bf 00 lds r24, 0x00BF
|
|
|
2371 |
990: 80 35 cpi r24, 0x50 ; 80
|
|
|
2372 |
992: 31 f4 brne .+12 ; 0x9a0
|
|
|
2373 |
994: 80 91 c0 00 lds r24, 0x00C0
|
|
|
2374 |
998: 87 34 cpi r24, 0x47 ; 71
|
|
|
2375 |
99a: 11 f4 brne .+4 ; 0x9a0
|
|
|
2376 |
(asciiTokenBuffer[1] == 'G') )
|
|
|
2377 |
{
|
|
|
2378 |
/* we got a "ping" command...but we still need to see
|
|
|
2379 |
if we are going to get the \r */
|
|
|
2380 |
receivedCmd = pingCmd;
|
|
|
2381 |
99c: 81 e0 ldi r24, 0x01 ; 1
|
|
|
2382 |
99e: 48 c0 rjmp .+144 ; 0xa30
|
|
|
2383 |
}
|
|
|
2384 |
else if ( (asciiTokenBuffer[0] == 'G') &&
|
|
|
2385 |
9a0: 80 91 bf 00 lds r24, 0x00BF
|
|
|
2386 |
9a4: 87 34 cpi r24, 0x47 ; 71
|
|
|
2387 |
9a6: 39 f4 brne .+14 ; 0x9b6
|
|
|
2388 |
9a8: 80 91 c0 00 lds r24, 0x00C0
|
|
|
2389 |
9ac: 86 35 cpi r24, 0x56 ; 86
|
|
|
2390 |
9ae: 19 f4 brne .+6 ; 0x9b6
|
|
|
2391 |
(asciiTokenBuffer[1] == 'V') )
|
|
|
2392 |
{
|
|
|
2393 |
/* we got the "get version" command */
|
|
|
2394 |
receivedCmd = getVersionCmd;
|
|
|
2395 |
9b0: 10 92 62 00 sts 0x0062, r1
|
|
|
2396 |
9b4: 3f c0 rjmp .+126 ; 0xa34
|
|
|
2397 |
}
|
|
|
2398 |
else if ( (asciiTokenBuffer[0] == 'D') &&
|
|
|
2399 |
9b6: 80 91 bf 00 lds r24, 0x00BF
|
|
|
2400 |
9ba: 84 34 cpi r24, 0x44 ; 68
|
|
|
2401 |
9bc: 31 f4 brne .+12 ; 0x9ca
|
|
|
2402 |
9be: 80 91 c0 00 lds r24, 0x00C0
|
|
|
2403 |
9c2: 86 34 cpi r24, 0x46 ; 70
|
|
|
2404 |
9c4: 11 f4 brne .+4 ; 0x9ca
|
|
|
2405 |
(asciiTokenBuffer[1] == 'F') )
|
|
|
2406 |
{
|
|
|
2407 |
/* we should go into frame dump mode */
|
|
|
2408 |
receivedCmd = dumpFrameCmd;
|
|
|
2409 |
9c6: 83 e0 ldi r24, 0x03 ; 3
|
|
|
2410 |
9c8: 33 c0 rjmp .+102 ; 0xa30
|
|
|
2411 |
}
|
|
|
2412 |
else if ( (asciiTokenBuffer[0] == 'C') &&
|
|
|
2413 |
9ca: 80 91 bf 00 lds r24, 0x00BF
|
|
|
2414 |
9ce: 83 34 cpi r24, 0x43 ; 67
|
|
|
2415 |
9d0: 31 f4 brne .+12 ; 0x9de
|
|
|
2416 |
9d2: 80 91 c0 00 lds r24, 0x00C0
|
|
|
2417 |
9d6: 82 35 cpi r24, 0x52 ; 82
|
|
|
2418 |
9d8: 11 f4 brne .+4 ; 0x9de
|
|
|
2419 |
(asciiTokenBuffer[1] == 'R') )
|
|
|
2420 |
{
|
|
|
2421 |
/* the user wants to set registers in the OV6620 */
|
|
|
2422 |
receivedCmd = setCameraRegsCmd;
|
|
|
2423 |
9da: 82 e0 ldi r24, 0x02 ; 2
|
|
|
2424 |
9dc: 29 c0 rjmp .+82 ; 0xa30
|
|
|
2425 |
}
|
|
|
2426 |
else if ( (asciiTokenBuffer[0] == 'E') &&
|
|
|
2427 |
9de: 80 91 bf 00 lds r24, 0x00BF
|
|
|
2428 |
9e2: 85 34 cpi r24, 0x45 ; 69
|
|
|
2429 |
9e4: 31 f4 brne .+12 ; 0x9f2
|
|
|
2430 |
9e6: 80 91 c0 00 lds r24, 0x00C0
|
|
|
2431 |
9ea: 84 35 cpi r24, 0x54 ; 84
|
|
|
2432 |
9ec: 11 f4 brne .+4 ; 0x9f2
|
|
|
2433 |
(asciiTokenBuffer[1] == 'T') )
|
|
|
2434 |
{
|
|
|
2435 |
/* the user wants to enable tracking */
|
|
|
2436 |
receivedCmd = enableTrackingCmd;
|
|
|
2437 |
9ee: 84 e0 ldi r24, 0x04 ; 4
|
|
|
2438 |
9f0: 1f c0 rjmp .+62 ; 0xa30
|
|
|
2439 |
}
|
|
|
2440 |
else if ( (asciiTokenBuffer[0] == 'S') &&
|
|
|
2441 |
9f2: 80 91 bf 00 lds r24, 0x00BF
|
|
|
2442 |
9f6: 83 35 cpi r24, 0x53 ; 83
|
|
|
2443 |
9f8: 31 f4 brne .+12 ; 0xa06
|
|
|
2444 |
9fa: 80 91 c0 00 lds r24, 0x00C0
|
|
|
2445 |
9fe: 8d 34 cpi r24, 0x4D ; 77
|
|
|
2446 |
a00: 11 f4 brne .+4 ; 0xa06
|
|
|
2447 |
(asciiTokenBuffer[1] == 'M') )
|
|
|
2448 |
{
|
|
|
2449 |
/* the user wants to set the color map */
|
|
|
2450 |
receivedCmd = setColorMapCmd;
|
|
|
2451 |
a02: 86 e0 ldi r24, 0x06 ; 6
|
|
|
2452 |
a04: 15 c0 rjmp .+42 ; 0xa30
|
|
|
2453 |
}
|
|
|
2454 |
else if ( (asciiTokenBuffer[0] == 'D') &&
|
|
|
2455 |
a06: 80 91 bf 00 lds r24, 0x00BF
|
|
|
2456 |
a0a: 84 34 cpi r24, 0x44 ; 68
|
|
|
2457 |
a0c: 31 f4 brne .+12 ; 0xa1a
|
|
|
2458 |
a0e: 80 91 c0 00 lds r24, 0x00C0
|
|
|
2459 |
a12: 84 35 cpi r24, 0x54 ; 84
|
|
|
2460 |
a14: 11 f4 brne .+4 ; 0xa1a
|
|
|
2461 |
(asciiTokenBuffer[1] == 'T') )
|
|
|
2462 |
{
|
|
|
2463 |
receivedCmd = disableTrackingCmd;
|
|
|
2464 |
a16: 85 e0 ldi r24, 0x05 ; 5
|
|
|
2465 |
a18: 0b c0 rjmp .+22 ; 0xa30
|
|
|
2466 |
}
|
|
|
2467 |
else if ( (asciiTokenBuffer[0] == 'R') &&
|
|
|
2468 |
a1a: 80 91 bf 00 lds r24, 0x00BF
|
|
|
2469 |
a1e: 82 35 cpi r24, 0x52 ; 82
|
|
|
2470 |
a20: 31 f4 brne .+12 ; 0xa2e
|
|
|
2471 |
a22: 80 91 c0 00 lds r24, 0x00C0
|
|
|
2472 |
a26: 83 35 cpi r24, 0x53 ; 83
|
|
|
2473 |
a28: 11 f4 brne .+4 ; 0xa2e
|
|
|
2474 |
(asciiTokenBuffer[1] == 'S') )
|
|
|
2475 |
{
|
|
|
2476 |
receivedCmd = resetCameraCmd;
|
|
|
2477 |
a2a: 87 e0 ldi r24, 0x07 ; 7
|
|
|
2478 |
a2c: 01 c0 rjmp .+2 ; 0xa30
|
|
|
2479 |
}
|
|
|
2480 |
else
|
|
|
2481 |
{
|
|
|
2482 |
/* don't recognize the cmd */
|
|
|
2483 |
receivedCmd = invalidCmd;
|
|
|
2484 |
a2e: 89 e0 ldi r24, 0x09 ; 9
|
|
|
2485 |
a30: 80 93 62 00 sts 0x0062, r24
|
|
|
2486 |
}
|
|
|
2487 |
memset(asciiTokenBuffer,0x00,MAX_TOKEN_LENGTH);
|
|
|
2488 |
a34: 83 e0 ldi r24, 0x03 ; 3
|
|
|
2489 |
a36: ef eb ldi r30, 0xBF ; 191
|
|
|
2490 |
a38: f0 e0 ldi r31, 0x00 ; 0
|
|
|
2491 |
a3a: 11 92 st Z+, r1
|
|
|
2492 |
a3c: 8a 95 dec r24
|
|
|
2493 |
a3e: e9 f7 brne .-6 ; 0xa3a
|
|
|
2494 |
charIndex = 0;
|
|
|
2495 |
a40: 10 92 bd 00 sts 0x00BD, r1
|
|
|
2496 |
charCount = 0;
|
|
|
2497 |
a44: 10 92 bc 00 sts 0x00BC, r1
|
|
|
2498 |
}
|
|
|
2499 |
a48: 08 95 ret
|
|
|
2500 |
|
|
|
2501 |
00000a4a <UIMgr_sendAck>:
|
|
|
2502 |
/***********************************************************
|
|
|
2503 |
Function Name: UIMgr_sendAck
|
|
|
2504 |
Function Description: This function is responsible for
|
|
|
2505 |
queuing up an ACK to be sent to the user.
|
|
|
2506 |
Inputs: none
|
|
|
2507 |
Outputs: none
|
|
|
2508 |
***********************************************************/
|
|
|
2509 |
static void UIMgr_sendAck(void)
|
|
|
2510 |
{
|
|
|
2511 |
UIMgr_writeTxFifo('A');
|
|
|
2512 |
a4a: 81 e4 ldi r24, 0x41 ; 65
|
|
|
2513 |
a4c: 6e d0 rcall .+220 ; 0xb2a
|
|
|
2514 |
UIMgr_writeTxFifo('C');
|
|
|
2515 |
a4e: 83 e4 ldi r24, 0x43 ; 67
|
|
|
2516 |
a50: 6c d0 rcall .+216 ; 0xb2a
|
|
|
2517 |
UIMgr_writeTxFifo('K');
|
|
|
2518 |
a52: 8b e4 ldi r24, 0x4B ; 75
|
|
|
2519 |
a54: 6a d0 rcall .+212 ; 0xb2a
|
|
|
2520 |
UIMgr_writeTxFifo('\r');
|
|
|
2521 |
a56: 8d e0 ldi r24, 0x0D ; 13
|
|
|
2522 |
a58: 68 d0 rcall .+208 ; 0xb2a
|
|
|
2523 |
}
|
|
|
2524 |
a5a: 08 95 ret
|
|
|
2525 |
|
|
|
2526 |
00000a5c <UIMgr_sendNck>:
|
|
|
2527 |
|
|
|
2528 |
/***********************************************************
|
|
|
2529 |
Function Name: UIMgr_sendNck
|
|
|
2530 |
Function Description: This function is responsible for
|
|
|
2531 |
queueing up an NCK to be sent to the user.
|
|
|
2532 |
Inputs: none
|
|
|
2533 |
Outputs: none
|
|
|
2534 |
***********************************************************/
|
|
|
2535 |
static void UIMgr_sendNck(void)
|
|
|
2536 |
{
|
|
|
2537 |
UIMgr_writeTxFifo('N');
|
|
|
2538 |
a5c: 8e e4 ldi r24, 0x4E ; 78
|
|
|
2539 |
a5e: 65 d0 rcall .+202 ; 0xb2a
|
|
|
2540 |
UIMgr_writeTxFifo('C');
|
|
|
2541 |
a60: 83 e4 ldi r24, 0x43 ; 67
|
|
|
2542 |
a62: 63 d0 rcall .+198 ; 0xb2a
|
|
|
2543 |
UIMgr_writeTxFifo('K');
|
|
|
2544 |
a64: 8b e4 ldi r24, 0x4B ; 75
|
|
|
2545 |
a66: 61 d0 rcall .+194 ; 0xb2a
|
|
|
2546 |
UIMgr_writeTxFifo('\r');
|
|
|
2547 |
a68: 8d e0 ldi r24, 0x0D ; 13
|
|
|
2548 |
a6a: 5f d0 rcall .+190 ; 0xb2a
|
|
|
2549 |
}
|
|
|
2550 |
a6c: 08 95 ret
|
|
|
2551 |
|
|
|
2552 |
00000a6e <UIMgr_writeBufferToTxFifo>:
|
|
|
2553 |
|
|
|
2554 |
|
|
|
2555 |
/***********************************************************
|
|
|
2556 |
Function Name: UIMgr_writeBufferToTxFifo
|
|
|
2557 |
Function Description: This function is responsible for
|
|
|
2558 |
placing "length" bytes into the tx FIFO.
|
|
|
2559 |
Inputs: pData - a pointer to the data to send
|
|
|
2560 |
length - the number of bytes to send
|
|
|
2561 |
Outputs: none
|
|
|
2562 |
***********************************************************/
|
|
|
2563 |
void UIMgr_writeBufferToTxFifo(unsigned char *pData, unsigned char length)
|
|
|
2564 |
{
|
|
|
2565 |
a6e: dc 01 movw r26, r24
|
|
|
2566 |
unsigned char tmpHead;
|
|
|
2567 |
if (length == 0)
|
|
|
2568 |
a70: 66 23 and r22, r22
|
|
|
2569 |
a72: a9 f0 breq .+42 ; 0xa9e
|
|
|
2570 |
{
|
|
|
2571 |
return;
|
|
|
2572 |
}
|
|
|
2573 |
|
|
|
2574 |
DISABLE_INTS();
|
|
|
2575 |
a74: f8 94 cli
|
|
|
2576 |
while(length-- != 0)
|
|
|
2577 |
a76: 61 50 subi r22, 0x01 ; 1
|
|
|
2578 |
a78: 6f 3f cpi r22, 0xFF ; 255
|
|
|
2579 |
a7a: 81 f0 breq .+32 ; 0xa9c
|
|
|
2580 |
a7c: 24 e9 ldi r18, 0x94 ; 148
|
|
|
2581 |
a7e: 32 e0 ldi r19, 0x02 ; 2
|
|
|
2582 |
{
|
|
|
2583 |
UIMgr_txFifo[UIMgr_txFifoHead] = *pData++;
|
|
|
2584 |
a80: 90 91 ba 00 lds r25, 0x00BA
|
|
|
2585 |
a84: f9 01 movw r30, r18
|
|
|
2586 |
a86: e9 0f add r30, r25
|
|
|
2587 |
a88: f1 1d adc r31, r1
|
|
|
2588 |
a8a: 8d 91 ld r24, X+
|
|
|
2589 |
a8c: 80 83 st Z, r24
|
|
|
2590 |
|
|
|
2591 |
/* now move the head up */
|
|
|
2592 |
tmpHead = (UIMgr_txFifoHead + 1) & (UI_MGR_TX_FIFO_MASK);
|
|
|
2593 |
a8e: 89 2f mov r24, r25
|
|
|
2594 |
a90: 8f 5f subi r24, 0xFF ; 255
|
|
|
2595 |
a92: 8f 73 andi r24, 0x3F ; 63
|
|
|
2596 |
UIMgr_txFifoHead = tmpHead;
|
|
|
2597 |
a94: 80 93 ba 00 sts 0x00BA, r24
|
|
|
2598 |
a98: 61 50 subi r22, 0x01 ; 1
|
|
|
2599 |
a9a: 90 f7 brcc .-28 ; 0xa80
|
|
|
2600 |
}
|
|
|
2601 |
ENABLE_INTS();
|
|
|
2602 |
a9c: 78 94 sei
|
|
|
2603 |
}
|
|
|
2604 |
a9e: 08 95 ret
|
|
|
2605 |
|
|
|
2606 |
00000aa0 <UIMgr_txBuffer>:
|
|
|
2607 |
|
|
|
2608 |
/***********************************************************
|
|
|
2609 |
Function Name: UIMgr_txBuffer
|
|
|
2610 |
Function Description: This function is responsible for
|
|
|
2611 |
sending 'length' bytes out using the UartInterface
|
|
|
2612 |
module.
|
|
|
2613 |
Inputs: pData - a pointer to the data to send
|
|
|
2614 |
length - the number of bytes to send
|
|
|
2615 |
Outputs: none
|
|
|
2616 |
***********************************************************/
|
|
|
2617 |
void UIMgr_txBuffer(unsigned char *pData, unsigned char length)
|
|
|
2618 |
{
|
|
|
2619 |
aa0: 0f 93 push r16
|
|
|
2620 |
aa2: 1f 93 push r17
|
|
|
2621 |
aa4: cf 93 push r28
|
|
|
2622 |
aa6: 8c 01 movw r16, r24
|
|
|
2623 |
aa8: c6 2f mov r28, r22
|
|
|
2624 |
while(length-- != 0)
|
|
|
2625 |
aaa: c1 50 subi r28, 0x01 ; 1
|
|
|
2626 |
aac: cf 3f cpi r28, 0xFF ; 255
|
|
|
2627 |
aae: 31 f0 breq .+12 ; 0xabc
|
|
|
2628 |
{
|
|
|
2629 |
UartInt_txByte(*pData++);
|
|
|
2630 |
ab0: f8 01 movw r30, r16
|
|
|
2631 |
ab2: 81 91 ld r24, Z+
|
|
|
2632 |
ab4: 8f 01 movw r16, r30
|
|
|
2633 |
ab6: 54 d0 rcall .+168 ; 0xb60
|
|
|
2634 |
ab8: c1 50 subi r28, 0x01 ; 1
|
|
|
2635 |
aba: d0 f7 brcc .-12 ; 0xab0
|
|
|
2636 |
}
|
|
|
2637 |
}
|
|
|
2638 |
abc: cf 91 pop r28
|
|
|
2639 |
abe: 1f 91 pop r17
|
|
|
2640 |
ac0: 0f 91 pop r16
|
|
|
2641 |
ac2: 08 95 ret
|
|
|
2642 |
|
|
|
2643 |
00000ac4 <UIMgr_flushTxBuffer>:
|
|
|
2644 |
|
|
|
2645 |
/***********************************************************
|
|
|
2646 |
Function Name: UIMgr_flushTxBuffer
|
|
|
2647 |
Function Description: This function is responsible for
|
|
|
2648 |
sending all data currently in the serial tx buffer
|
|
|
2649 |
to the user.
|
|
|
2650 |
Inputs: none
|
|
|
2651 |
Outputs: none
|
|
|
2652 |
***********************************************************/
|
|
|
2653 |
void UIMgr_flushTxBuffer(void)
|
|
|
2654 |
{
|
|
|
2655 |
while(IS_DATA_IN_TX_FIFO() == TRUE)
|
|
|
2656 |
ac4: 90 91 ba 00 lds r25, 0x00BA
|
|
|
2657 |
ac8: 80 91 bb 00 lds r24, 0x00BB
|
|
|
2658 |
acc: 98 17 cp r25, r24
|
|
|
2659 |
ace: 41 f0 breq .+16 ; 0xae0
|
|
|
2660 |
{
|
|
|
2661 |
UartInt_txByte(UIMgr_readTxFifo() );
|
|
|
2662 |
ad0: 1a d0 rcall .+52 ; 0xb06
|
|
|
2663 |
ad2: 46 d0 rcall .+140 ; 0xb60
|
|
|
2664 |
ad4: 90 91 ba 00 lds r25, 0x00BA
|
|
|
2665 |
ad8: 80 91 bb 00 lds r24, 0x00BB
|
|
|
2666 |
adc: 98 17 cp r25, r24
|
|
|
2667 |
ade: c1 f7 brne .-16 ; 0xad0
|
|
|
2668 |
}
|
|
|
2669 |
}
|
|
|
2670 |
ae0: 08 95 ret
|
|
|
2671 |
|
|
|
2672 |
00000ae2 <UIMgr_readRxFifo>:
|
|
|
2673 |
|
|
|
2674 |
/***********************************************************
|
|
|
2675 |
Function Name: UIMgr_readRxFifo
|
|
|
2676 |
Function Description: This function is responsible for
|
|
|
2677 |
reading a single byte of data from the rx fifo, and
|
|
|
2678 |
updating the appropriate pointers.
|
|
|
2679 |
Inputs: none
|
|
|
2680 |
Outputs: unsigned char-the data read
|
|
|
2681 |
***********************************************************/
|
|
|
2682 |
static unsigned char UIMgr_readRxFifo(void)
|
|
|
2683 |
{
|
|
|
2684 |
unsigned char dataByte, tmpTail;
|
|
|
2685 |
|
|
|
2686 |
/* just return the current tail from the rx fifo */
|
|
|
2687 |
DISABLE_INTS();
|
|
|
2688 |
ae2: f8 94 cli
|
|
|
2689 |
dataByte = UIMgr_rxFifo[UIMgr_rxFifoTail];
|
|
|
2690 |
ae4: 20 91 b9 00 lds r18, 0x00B9
|
|
|
2691 |
ae8: 84 e7 ldi r24, 0x74 ; 116
|
|
|
2692 |
aea: 92 e0 ldi r25, 0x02 ; 2
|
|
|
2693 |
aec: fc 01 movw r30, r24
|
|
|
2694 |
aee: e2 0f add r30, r18
|
|
|
2695 |
af0: f1 1d adc r31, r1
|
|
|
2696 |
af2: 90 81 ld r25, Z
|
|
|
2697 |
tmpTail = (UIMgr_rxFifoTail+1) & (UI_MGR_RX_FIFO_MASK);
|
|
|
2698 |
af4: 82 2f mov r24, r18
|
|
|
2699 |
af6: 8f 5f subi r24, 0xFF ; 255
|
|
|
2700 |
af8: 8f 71 andi r24, 0x1F ; 31
|
|
|
2701 |
UIMgr_rxFifoTail = tmpTail;
|
|
|
2702 |
afa: 80 93 b9 00 sts 0x00B9, r24
|
|
|
2703 |
ENABLE_INTS();
|
|
|
2704 |
afe: 78 94 sei
|
|
|
2705 |
|
|
|
2706 |
return(dataByte);
|
|
|
2707 |
b00: 89 2f mov r24, r25
|
|
|
2708 |
b02: 99 27 eor r25, r25
|
|
|
2709 |
}
|
|
|
2710 |
b04: 08 95 ret
|
|
|
2711 |
|
|
|
2712 |
00000b06 <UIMgr_readTxFifo>:
|
|
|
2713 |
|
|
|
2714 |
/***********************************************************
|
|
|
2715 |
Function Name: UIMgr_readTxFifo
|
|
|
2716 |
Function Description: This function is responsible for
|
|
|
2717 |
reading a single byte of data from the tx fifo, and
|
|
|
2718 |
updating the appropriate pointers.
|
|
|
2719 |
Inputs: none
|
|
|
2720 |
Outputs: unsigned char-the data read
|
|
|
2721 |
***********************************************************/
|
|
|
2722 |
static unsigned char UIMgr_readTxFifo(void)
|
|
|
2723 |
{
|
|
|
2724 |
unsigned char dataByte, tmpTail;
|
|
|
2725 |
|
|
|
2726 |
/* just return the current tail from the tx fifo */
|
|
|
2727 |
DISABLE_INTS();
|
|
|
2728 |
b06: f8 94 cli
|
|
|
2729 |
dataByte = UIMgr_txFifo[UIMgr_txFifoTail];
|
|
|
2730 |
b08: 20 91 bb 00 lds r18, 0x00BB
|
|
|
2731 |
b0c: 84 e9 ldi r24, 0x94 ; 148
|
|
|
2732 |
b0e: 92 e0 ldi r25, 0x02 ; 2
|
|
|
2733 |
b10: fc 01 movw r30, r24
|
|
|
2734 |
b12: e2 0f add r30, r18
|
|
|
2735 |
b14: f1 1d adc r31, r1
|
|
|
2736 |
b16: 90 81 ld r25, Z
|
|
|
2737 |
tmpTail = (UIMgr_txFifoTail+1) & (UI_MGR_TX_FIFO_MASK);
|
|
|
2738 |
b18: 82 2f mov r24, r18
|
|
|
2739 |
b1a: 8f 5f subi r24, 0xFF ; 255
|
|
|
2740 |
b1c: 8f 73 andi r24, 0x3F ; 63
|
|
|
2741 |
UIMgr_txFifoTail = tmpTail;
|
|
|
2742 |
b1e: 80 93 bb 00 sts 0x00BB, r24
|
|
|
2743 |
ENABLE_INTS();
|
|
|
2744 |
b22: 78 94 sei
|
|
|
2745 |
|
|
|
2746 |
return(dataByte);
|
|
|
2747 |
b24: 89 2f mov r24, r25
|
|
|
2748 |
b26: 99 27 eor r25, r25
|
|
|
2749 |
}
|
|
|
2750 |
b28: 08 95 ret
|
|
|
2751 |
|
|
|
2752 |
00000b2a <UIMgr_writeTxFifo>:
|
|
|
2753 |
|
|
|
2754 |
/***********************************************************
|
|
|
2755 |
Function Name: UIMgr_writeTxFifo
|
|
|
2756 |
Function Description: This function is responsible for
|
|
|
2757 |
writing a single byte to the TxFifo and
|
|
|
2758 |
updating the appropriate pointers.
|
|
|
2759 |
Inputs: data - the byte to write to the Fifo
|
|
|
2760 |
Outputs: none
|
|
|
2761 |
***********************************************************/
|
|
|
2762 |
void UIMgr_writeTxFifo(unsigned char data)
|
|
|
2763 |
{
|
|
|
2764 |
b2a: 38 2f mov r19, r24
|
|
|
2765 |
unsigned char tmpHead;
|
|
|
2766 |
|
|
|
2767 |
DISABLE_INTS();
|
|
|
2768 |
b2c: f8 94 cli
|
|
|
2769 |
UIMgr_txFifo[UIMgr_txFifoHead] = data;
|
|
|
2770 |
b2e: 20 91 ba 00 lds r18, 0x00BA
|
|
|
2771 |
b32: 84 e9 ldi r24, 0x94 ; 148
|
|
|
2772 |
b34: 92 e0 ldi r25, 0x02 ; 2
|
|
|
2773 |
b36: fc 01 movw r30, r24
|
|
|
2774 |
b38: e2 0f add r30, r18
|
|
|
2775 |
b3a: f1 1d adc r31, r1
|
|
|
2776 |
b3c: 30 83 st Z, r19
|
|
|
2777 |
|
|
|
2778 |
/* now move the head up */
|
|
|
2779 |
tmpHead = (UIMgr_txFifoHead + 1) & (UI_MGR_TX_FIFO_MASK);
|
|
|
2780 |
b3e: 82 2f mov r24, r18
|
|
|
2781 |
b40: 8f 5f subi r24, 0xFF ; 255
|
|
|
2782 |
b42: 8f 73 andi r24, 0x3F ; 63
|
|
|
2783 |
UIMgr_txFifoHead = tmpHead;
|
|
|
2784 |
b44: 80 93 ba 00 sts 0x00BA, r24
|
|
|
2785 |
ENABLE_INTS();
|
|
|
2786 |
b48: 78 94 sei
|
|
|
2787 |
|
|
|
2788 |
}
|
|
|
2789 |
b4a: 08 95 ret
|
|
|
2790 |
|
|
|
2791 |
00000b4c <UartInt_init>:
|
|
|
2792 |
void UartInt_init(void)
|
|
|
2793 |
{
|
|
|
2794 |
/* set up the baud rate registers so the UART will operate
|
|
|
2795 |
at 115.2 Kbps */
|
|
|
2796 |
UBRRH = 0x00;
|
|
|
2797 |
b4c: 10 bc out 0x20, r1 ; 32
|
|
|
2798 |
|
|
|
2799 |
#ifdef NO_CRYSTAL
|
|
|
2800 |
UBRRL = 18; /* 18 for double clocking at 115.2 kbps */
|
|
|
2801 |
b4e: 82 e1 ldi r24, 0x12 ; 18
|
|
|
2802 |
b50: 89 b9 out 0x09, r24 ; 9
|
|
|
2803 |
#else
|
|
|
2804 |
UBRRL = 0x08; /* for 16 MHz crystal at 115.2 kbps */
|
|
|
2805 |
#endif
|
|
|
2806 |
|
|
|
2807 |
/* enable the tx and rx capabilities of the UART...as well
|
|
|
2808 |
as the receive complete interrupt */
|
|
|
2809 |
UCSRB = (1<<RXCIE)|(1<<RXEN)|(1<<TXEN);
|
|
|
2810 |
b52: 88 e9 ldi r24, 0x98 ; 152
|
|
|
2811 |
b54: 8a b9 out 0x0a, r24 ; 10
|
|
|
2812 |
|
|
|
2813 |
/* set up the control registers so the UART works at 8N1 */
|
|
|
2814 |
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);
|
|
|
2815 |
b56: 86 e8 ldi r24, 0x86 ; 134
|
|
|
2816 |
b58: 80 bd out 0x20, r24 ; 32
|
|
|
2817 |
|
|
|
2818 |
#ifdef NO_CRYSTAL
|
|
|
2819 |
/* set the baud rate to use the double-speed */
|
|
|
2820 |
UCSRA = (1<<U2X);
|
|
|
2821 |
b5a: 82 e0 ldi r24, 0x02 ; 2
|
|
|
2822 |
b5c: 8b b9 out 0x0b, r24 ; 11
|
|
|
2823 |
#endif
|
|
|
2824 |
|
|
|
2825 |
}
|
|
|
2826 |
b5e: 08 95 ret
|
|
|
2827 |
|
|
|
2828 |
00000b60 <UartInt_txByte>:
|
|
|
2829 |
|
|
|
2830 |
/***********************************************************
|
|
|
2831 |
Function Name: UartInt_txByte
|
|
|
2832 |
Function Description: This function is responsible for
|
|
|
2833 |
transmitting a single byte on the uart.
|
|
|
2834 |
Inputs: txByte - the byte to send
|
|
|
2835 |
Outputs: none
|
|
|
2836 |
NOTES: When the TX UDRE (data register empty) is set, there
|
|
|
2837 |
is puposefully no interrupt...thus, to send a string of
|
|
|
2838 |
data out, the calling routine needs to hold up the entire
|
|
|
2839 |
application while this takes place (or just send one
|
|
|
2840 |
byte at a time at strtegically timed intervals, like
|
|
|
2841 |
the stats data is sent out :-)
|
|
|
2842 |
***********************************************************/
|
|
|
2843 |
void UartInt_txByte(unsigned char txByte)
|
|
|
2844 |
{
|
|
|
2845 |
/* Wait for empty transmit buffer */
|
|
|
2846 |
while ( !( UCSRA & (1<<UDRE)) );
|
|
|
2847 |
b60: 5d 9b sbis 0x0b, 5 ; 11
|
|
|
2848 |
b62: fe cf rjmp .-4 ; 0xb60
|
|
|
2849 |
/* Put data into buffer, sends the data */
|
|
|
2850 |
UDR = txByte;
|
|
|
2851 |
b64: 8c b9 out 0x0c, r24 ; 12
|
|
|
2852 |
}
|
|
|
2853 |
b66: 08 95 ret
|
|
|
2854 |
|
|
|
2855 |
00000b68 <__vector_11>:
|
|
|
2856 |
|
|
|
2857 |
/***********************************************************
|
|
|
2858 |
Function Name: SIG_UART_RECV ISR
|
|
|
2859 |
Function Description: This function is responsible for
|
|
|
2860 |
handling the interrupt caused when a data byte is
|
|
|
2861 |
received by the UART.
|
|
|
2862 |
Inputs: none
|
|
|
2863 |
Outputs: none
|
|
|
2864 |
NOTES: This function was originally written in assembly,
|
|
|
2865 |
but moved over to C when the setting of the "T" bit at
|
|
|
2866 |
the end of the routine was no longer necessary (this
|
|
|
2867 |
theoretically allowed the AVRcam to respond to serial
|
|
|
2868 |
bytes in the middle of tracking or dumping a frame.
|
|
|
2869 |
But it wasn't really needed, and understanding the C
|
|
|
2870 |
is easier :-)
|
|
|
2871 |
***********************************************************/
|
|
|
2872 |
SIGNAL(SIG_UART_RECV)
|
|
|
2873 |
{
|
|
|
2874 |
b68: 1f 92 push r1
|
|
|
2875 |
b6a: 0f 92 push r0
|
|
|
2876 |
b6c: 0f b6 in r0, 0x3f ; 63
|
|
|
2877 |
b6e: 0f 92 push r0
|
|
|
2878 |
b70: 11 24 eor r1, r1
|
|
|
2879 |
b72: 2f 93 push r18
|
|
|
2880 |
b74: 8f 93 push r24
|
|
|
2881 |
b76: 9f 93 push r25
|
|
|
2882 |
b78: ef 93 push r30
|
|
|
2883 |
b7a: ff 93 push r31
|
|
|
2884 |
unsigned char tmpHead;
|
|
|
2885 |
/* read the data byte, put it in the serial queue, and
|
|
|
2886 |
post the event */
|
|
|
2887 |
|
|
|
2888 |
UIMgr_rxFifo[UIMgr_rxFifoHead] = UDR;
|
|
|
2889 |
b7c: 20 91 b8 00 lds r18, 0x00B8
|
|
|
2890 |
b80: 84 e7 ldi r24, 0x74 ; 116
|
|
|
2891 |
b82: 92 e0 ldi r25, 0x02 ; 2
|
|
|
2892 |
b84: fc 01 movw r30, r24
|
|
|
2893 |
b86: e2 0f add r30, r18
|
|
|
2894 |
b88: f1 1d adc r31, r1
|
|
|
2895 |
b8a: 8c b1 in r24, 0x0c ; 12
|
|
|
2896 |
b8c: 80 83 st Z, r24
|
|
|
2897 |
|
|
|
2898 |
/* now move the head up */
|
|
|
2899 |
tmpHead = (UIMgr_rxFifoHead + 1) & (UI_MGR_RX_FIFO_MASK);
|
|
|
2900 |
b8e: 2f 5f subi r18, 0xFF ; 255
|
|
|
2901 |
b90: 2f 71 andi r18, 0x1F ; 31
|
|
|
2902 |
UIMgr_rxFifoHead = tmpHead;
|
|
|
2903 |
b92: 20 93 b8 00 sts 0x00B8, r18
|
|
|
2904 |
|
|
|
2905 |
/* write the serial received event to the event fifo */
|
|
|
2906 |
Exec_eventFifo[Exec_eventFifoHead] = EV_SERIAL_DATA_RECEIVED;
|
|
|
2907 |
b96: 20 91 70 00 lds r18, 0x0070
|
|
|
2908 |
b9a: 8c e6 ldi r24, 0x6C ; 108
|
|
|
2909 |
b9c: 92 e0 ldi r25, 0x02 ; 2
|
|
|
2910 |
b9e: fc 01 movw r30, r24
|
|
|
2911 |
ba0: e2 0f add r30, r18
|
|
|
2912 |
ba2: f1 1d adc r31, r1
|
|
|
2913 |
ba4: 81 e0 ldi r24, 0x01 ; 1
|
|
|
2914 |
ba6: 80 83 st Z, r24
|
|
|
2915 |
|
|
|
2916 |
/* now move the head up */
|
|
|
2917 |
tmpHead = (Exec_eventFifoHead + 1) & (EXEC_EVENT_FIFO_MASK);
|
|
|
2918 |
ba8: 28 0f add r18, r24
|
|
|
2919 |
baa: 27 70 andi r18, 0x07 ; 7
|
|
|
2920 |
Exec_eventFifoHead = tmpHead;
|
|
|
2921 |
bac: 20 93 70 00 sts 0x0070, r18
|
|
|
2922 |
}
|
|
|
2923 |
bb0: ff 91 pop r31
|
|
|
2924 |
bb2: ef 91 pop r30
|
|
|
2925 |
bb4: 9f 91 pop r25
|
|
|
2926 |
bb6: 8f 91 pop r24
|
|
|
2927 |
bb8: 2f 91 pop r18
|
|
|
2928 |
bba: 0f 90 pop r0
|
|
|
2929 |
bbc: 0f be out 0x3f, r0 ; 63
|
|
|
2930 |
bbe: 0f 90 pop r0
|
|
|
2931 |
bc0: 1f 90 pop r1
|
|
|
2932 |
bc2: 18 95 reti
|
|
|
2933 |
|
|
|
2934 |
00000bc4 <I2CInt_init>:
|
|
|
2935 |
Outputs: none
|
|
|
2936 |
***********************************************************/
|
|
|
2937 |
void I2CInt_init(void)
|
|
|
2938 |
{
|
|
|
2939 |
TWSR = 0;
|
|
|
2940 |
bc4: 11 b8 out 0x01, r1 ; 1
|
|
|
2941 |
|
|
|
2942 |
/* init the speed of the I2C interface, running at
|
|
|
2943 |
100 Kbps */
|
|
|
2944 |
TWBR = (FOSC / I2C_SPEED - 16)/2;
|
|
|
2945 |
bc6: 88 e4 ldi r24, 0x48 ; 72
|
|
|
2946 |
bc8: 80 b9 out 0x00, r24 ; 0
|
|
|
2947 |
}
|
|
|
2948 |
bca: 08 95 ret
|
|
|
2949 |
|
|
|
2950 |
00000bcc <I2CInt_writeData>:
|
|
|
2951 |
|
|
|
2952 |
/***********************************************************
|
|
|
2953 |
Function Name: I2CInt_writeData
|
|
|
2954 |
Function Description: This function is responsible for
|
|
|
2955 |
initiating the process of writing a sequence of bytes
|
|
|
2956 |
an I2C slave address. This function will try to write
|
|
|
2957 |
the data three times before giving up.
|
|
|
2958 |
Inputs: address: the address of the I2C slave device
|
|
|
2959 |
data: a pointer to the data to be written
|
|
|
2960 |
to the slave...for camera interfacing,
|
|
|
2961 |
the data follows a <register #><data>
|
|
|
2962 |
format
|
|
|
2963 |
bytes: the number of bytes to write
|
|
|
2964 |
Outputs: none
|
|
|
2965 |
***********************************************************/
|
|
|
2966 |
void I2CInt_writeData(unsigned char address, unsigned char *data, unsigned char bytes)
|
|
|
2967 |
{
|
|
|
2968 |
bcc: 98 2f mov r25, r24
|
|
|
2969 |
while(status & (1<<BUSY)); /* Bus is busy wait (or exit with error code) */
|
|
|
2970 |
bce: 80 91 08 01 lds r24, 0x0108
|
|
|
2971 |
bd2: 88 23 and r24, r24
|
|
|
2972 |
bd4: e4 f3 brlt .-8 ; 0xbce
|
|
|
2973 |
while(TWCR & (1<<TWSTO));
|
|
|
2974 |
bd6: 06 b6 in r0, 0x36 ; 54
|
|
|
2975 |
bd8: 04 fc sbrc r0, 4
|
|
|
2976 |
bda: fd cf rjmp .-6 ; 0xbd6
|
|
|
2977 |
|
|
|
2978 |
/* copy the needed data and state info to our local I2C command structure */
|
|
|
2979 |
twi_address = address;
|
|
|
2980 |
bdc: 90 93 03 01 sts 0x0103, r25
|
|
|
2981 |
twi_data = data;
|
|
|
2982 |
be0: 70 93 05 01 sts 0x0105, r23
|
|
|
2983 |
be4: 60 93 04 01 sts 0x0104, r22
|
|
|
2984 |
twi_bytes = bytes;
|
|
|
2985 |
be8: 40 93 07 01 sts 0x0107, r20
|
|
|
2986 |
twi_ddr = TW_WRITE;
|
|
|
2987 |
bec: 10 92 06 01 sts 0x0106, r1
|
|
|
2988 |
|
|
|
2989 |
retry_cnt = 0;
|
|
|
2990 |
bf0: 10 92 09 01 sts 0x0109, r1
|
|
|
2991 |
|
|
|
2992 |
/* Generate start condition, the remainder of the transfer is interrupt driven and
|
|
|
2993 |
will be performed in the background */
|
|
|
2994 |
TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN)|(1<<TWIE);
|
|
|
2995 |
bf4: 85 ea ldi r24, 0xA5 ; 165
|
|
|
2996 |
bf6: 86 bf out 0x36, r24 ; 54
|
|
|
2997 |
|
|
|
2998 |
status |= (1<<BUSY);
|
|
|
2999 |
bf8: 80 91 08 01 lds r24, 0x0108
|
|
|
3000 |
bfc: 80 68 ori r24, 0x80 ; 128
|
|
|
3001 |
bfe: 80 93 08 01 sts 0x0108, r24
|
|
|
3002 |
}
|
|
|
3003 |
c02: 08 95 ret
|
|
|
3004 |
|
|
|
3005 |
00000c04 <I2CInt_readData>:
|
|
|
3006 |
|
|
|
3007 |
/***********************************************************
|
|
|
3008 |
Function Name: I2CInt_readData
|
|
|
3009 |
Function Description: This funcion is responsible for
|
|
|
3010 |
reading the specified number of bytes from a slave
|
|
|
3011 |
device.
|
|
|
3012 |
Inputs: address: the slave address to read from
|
|
|
3013 |
data: a pointer to where the data will be stored
|
|
|
3014 |
bytes: the number of bytes to read
|
|
|
3015 |
Outputs: none
|
|
|
3016 |
***********************************************************/
|
|
|
3017 |
void I2CInt_readData(unsigned char address, unsigned char *data, unsigned char bytes)
|
|
|
3018 |
{
|
|
|
3019 |
c04: 98 2f mov r25, r24
|
|
|
3020 |
/* Bus is busy wait (or exit with error code) */
|
|
|
3021 |
while(status & (1<<BUSY));
|
|
|
3022 |
c06: 80 91 08 01 lds r24, 0x0108
|
|
|
3023 |
c0a: 88 23 and r24, r24
|
|
|
3024 |
c0c: e4 f3 brlt .-8 ; 0xc06
|
|
|
3025 |
|
|
|
3026 |
twi_address = address;
|
|
|
3027 |
c0e: 90 93 03 01 sts 0x0103, r25
|
|
|
3028 |
twi_data = data;
|
|
|
3029 |
c12: 70 93 05 01 sts 0x0105, r23
|
|
|
3030 |
c16: 60 93 04 01 sts 0x0104, r22
|
|
|
3031 |
twi_bytes = bytes;
|
|
|
3032 |
c1a: 40 93 07 01 sts 0x0107, r20
|
|
|
3033 |
twi_ddr = TW_READ;
|
|
|
3034 |
c1e: 81 e0 ldi r24, 0x01 ; 1
|
|
|
3035 |
c20: 80 93 06 01 sts 0x0106, r24
|
|
|
3036 |
|
|
|
3037 |
retry_cnt = 0;
|
|
|
3038 |
c24: 10 92 09 01 sts 0x0109, r1
|
|
|
3039 |
|
|
|
3040 |
/* Generate start condition, the remainder of the transfer is interrupt driven and
|
|
|
3041 |
will be performed in the background */
|
|
|
3042 |
TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN)|(1<<TWIE);
|
|
|
3043 |
c28: 85 ea ldi r24, 0xA5 ; 165
|
|
|
3044 |
c2a: 86 bf out 0x36, r24 ; 54
|
|
|
3045 |
|
|
|
3046 |
status |= (1<<BUSY);
|
|
|
3047 |
c2c: 80 91 08 01 lds r24, 0x0108
|
|
|
3048 |
c30: 80 68 ori r24, 0x80 ; 128
|
|
|
3049 |
c32: 80 93 08 01 sts 0x0108, r24
|
|
|
3050 |
}
|
|
|
3051 |
c36: 08 95 ret
|
|
|
3052 |
|
|
|
3053 |
00000c38 <I2CInt_isI2cBusy>:
|
|
|
3054 |
|
|
|
3055 |
/***********************************************************
|
|
|
3056 |
Function Name: I2CInt_isI2cBusy
|
|
|
3057 |
Function Description: This funcion is responsible for
|
|
|
3058 |
indicating if the I2C bus is currently busy to external
|
|
|
3059 |
modules.
|
|
|
3060 |
device.
|
|
|
3061 |
Inputs: none
|
|
|
3062 |
Outputs: bool_t - indicating if bus is busy
|
|
|
3063 |
***********************************************************/
|
|
|
3064 |
bool_t I2CInt_isI2cBusy(void)
|
|
|
3065 |
{
|
|
|
3066 |
bool_t retVal = FALSE;
|
|
|
3067 |
c38: 90 e0 ldi r25, 0x00 ; 0
|
|
|
3068 |
if ( (status & (1<<BUSY)) != 0)
|
|
|
3069 |
c3a: 80 91 08 01 lds r24, 0x0108
|
|
|
3070 |
c3e: 88 23 and r24, r24
|
|
|
3071 |
c40: 0c f4 brge .+2 ; 0xc44
|
|
|
3072 |
{
|
|
|
3073 |
retVal = TRUE;
|
|
|
3074 |
c42: 91 e0 ldi r25, 0x01 ; 1
|
|
|
3075 |
}
|
|
|
3076 |
|
|
|
3077 |
return(retVal);
|
|
|
3078 |
c44: 89 2f mov r24, r25
|
|
|
3079 |
c46: 99 27 eor r25, r25
|
|
|
3080 |
}
|
|
|
3081 |
c48: 08 95 ret
|
|
|
3082 |
|
|
|
3083 |
00000c4a <__vector_17>:
|
|
|
3084 |
|
|
|
3085 |
/***********************************************************
|
|
|
3086 |
Function Name: <interrupt handler for I2C>
|
|
|
3087 |
Function Description: This function is responsible for
|
|
|
3088 |
implementing the control logic needed to perform a
|
|
|
3089 |
read or write operation with an I2C slave.
|
|
|
3090 |
Inputs: none
|
|
|
3091 |
Outputs: none
|
|
|
3092 |
***********************************************************/
|
|
|
3093 |
SIGNAL(SIG_2WIRE_SERIAL)
|
|
|
3094 |
{
|
|
|
3095 |
c4a: 1f 92 push r1
|
|
|
3096 |
c4c: 0f 92 push r0
|
|
|
3097 |
c4e: 0f b6 in r0, 0x3f ; 63
|
|
|
3098 |
c50: 0f 92 push r0
|
|
|
3099 |
c52: 11 24 eor r1, r1
|
|
|
3100 |
c54: 8f 93 push r24
|
|
|
3101 |
c56: 9f 93 push r25
|
|
|
3102 |
c58: af 93 push r26
|
|
|
3103 |
c5a: bf 93 push r27
|
|
|
3104 |
c5c: ef 93 push r30
|
|
|
3105 |
c5e: ff 93 push r31
|
|
|
3106 |
unsigned char TWI_status = TWSR & TW_STATUS_MASK; /* grab just the status bits */
|
|
|
3107 |
c60: 81 b1 in r24, 0x01 ; 1
|
|
|
3108 |
c62: 88 7f andi r24, 0xF8 ; 248
|
|
|
3109 |
|
|
|
3110 |
/* the entire I2C handler is state-based...determine
|
|
|
3111 |
what needs to be done based on TWI_status */
|
|
|
3112 |
switch(TWI_status)
|
|
|
3113 |
c64: 99 27 eor r25, r25
|
|
|
3114 |
c66: aa 27 eor r26, r26
|
|
|
3115 |
c68: bb 27 eor r27, r27
|
|
|
3116 |
c6a: fc 01 movw r30, r24
|
|
|
3117 |
c6c: 38 97 sbiw r30, 0x08 ; 8
|
|
|
3118 |
c6e: e1 35 cpi r30, 0x51 ; 81
|
|
|
3119 |
c70: f1 05 cpc r31, r1
|
|
|
3120 |
c72: 08 f0 brcs .+2 ; 0xc76
|
|
|
3121 |
c74: 6d c0 rjmp .+218 ; 0xd50
|
|
|
3122 |
c76: ed 5e subi r30, 0xED ; 237
|
|
|
3123 |
c78: ff 4f sbci r31, 0xFF ; 255
|
|
|
3124 |
c7a: 09 94 ijmp
|
|
|
3125 |
{
|
|
|
3126 |
case TW_START: /* Start condition */
|
|
|
3127 |
case TW_REP_START: /* Repeated start condition */
|
|
|
3128 |
if(retry_cnt > MAX_TWI_RETRIES)
|
|
|
3129 |
c7c: 80 91 09 01 lds r24, 0x0109
|
|
|
3130 |
c80: 83 30 cpi r24, 0x03 ; 3
|
|
|
3131 |
c82: 08 f0 brcs .+2 ; 0xc86
|
|
|
3132 |
c84: 5d c0 rjmp .+186 ; 0xd40
|
|
|
3133 |
{
|
|
|
3134 |
/* generate stop condition if we've reached our retry limit */
|
|
|
3135 |
TWCR |= (1<<TWINT)|(1<<TWSTO);
|
|
|
3136 |
status &= ~(1<<BUSY);
|
|
|
3137 |
return;
|
|
|
3138 |
}
|
|
|
3139 |
/* indicate read or write */
|
|
|
3140 |
TWDR = (twi_address<<1) + twi_ddr;
|
|
|
3141 |
c86: 80 91 03 01 lds r24, 0x0103
|
|
|
3142 |
c8a: 98 2f mov r25, r24
|
|
|
3143 |
c8c: 99 0f add r25, r25
|
|
|
3144 |
c8e: 80 91 06 01 lds r24, 0x0106
|
|
|
3145 |
c92: 89 0f add r24, r25
|
|
|
3146 |
c94: 83 b9 out 0x03, r24 ; 3
|
|
|
3147 |
/* TWSTA must be cleared...also clears TWINT */
|
|
|
3148 |
TWCR &= ~(1<<TWSTA);
|
|
|
3149 |
c96: 86 b7 in r24, 0x36 ; 54
|
|
|
3150 |
c98: 8f 7d andi r24, 0xDF ; 223
|
|
|
3151 |
c9a: 4a c0 rjmp .+148 ; 0xd30
|
|
|
3152 |
break;
|
|
|
3153 |
|
|
|
3154 |
case TW_MT_SLA_ACK: /* Slave acknowledged address, */
|
|
|
3155 |
retry_cnt = 0;
|
|
|
3156 |
c9c: 10 92 09 01 sts 0x0109, r1
|
|
|
3157 |
/* tx the data, and increment the data pointer */
|
|
|
3158 |
TWDR = *twi_data;
|
|
|
3159 |
ca0: 11 c0 rjmp .+34 ; 0xcc4
|
|
|
3160 |
twi_data++;
|
|
|
3161 |
|
|
|
3162 |
/* clear the int to continue */
|
|
|
3163 |
TWCR |= (1<<TWINT);
|
|
|
3164 |
break;
|
|
|
3165 |
|
|
|
3166 |
case TW_MT_SLA_NACK: /* Slave didn't acknowledge address, */
|
|
|
3167 |
case TW_MR_SLA_NACK:
|
|
|
3168 |
retry_cnt++;
|
|
|
3169 |
ca2: 80 91 09 01 lds r24, 0x0109
|
|
|
3170 |
ca6: 8f 5f subi r24, 0xFF ; 255
|
|
|
3171 |
ca8: 80 93 09 01 sts 0x0109, r24
|
|
|
3172 |
|
|
|
3173 |
/* retry...*/
|
|
|
3174 |
TWCR |= (1<<TWINT)|(1<<TWSTA)|(1<<TWSTO);
|
|
|
3175 |
cac: 86 b7 in r24, 0x36 ; 54
|
|
|
3176 |
cae: 80 6b ori r24, 0xB0 ; 176
|
|
|
3177 |
cb0: 3f c0 rjmp .+126 ; 0xd30
|
|
|
3178 |
break;
|
|
|
3179 |
|
|
|
3180 |
case TW_MT_DATA_ACK: /* Slave Acknowledged data, */
|
|
|
3181 |
if(--twi_bytes > 0)
|
|
|
3182 |
cb2: 80 91 07 01 lds r24, 0x0107
|
|
|
3183 |
cb6: 81 50 subi r24, 0x01 ; 1
|
|
|
3184 |
cb8: 80 93 07 01 sts 0x0107, r24
|
|
|
3185 |
cbc: 80 91 07 01 lds r24, 0x0107
|
|
|
3186 |
cc0: 88 23 and r24, r24
|
|
|
3187 |
cc2: f1 f1 breq .+124 ; 0xd40
|
|
|
3188 |
{
|
|
|
3189 |
/* more data to send, so send it */
|
|
|
3190 |
TWDR = *twi_data;
|
|
|
3191 |
cc4: e0 91 04 01 lds r30, 0x0104
|
|
|
3192 |
cc8: f0 91 05 01 lds r31, 0x0105
|
|
|
3193 |
ccc: 80 81 ld r24, Z
|
|
|
3194 |
cce: 83 b9 out 0x03, r24 ; 3
|
|
|
3195 |
twi_data++;
|
|
|
3196 |
cd0: cf 01 movw r24, r30
|
|
|
3197 |
cd2: 01 96 adiw r24, 0x01 ; 1
|
|
|
3198 |
cd4: 90 93 05 01 sts 0x0105, r25
|
|
|
3199 |
cd8: 80 93 04 01 sts 0x0104, r24
|
|
|
3200 |
TWCR |= (1<<TWINT);
|
|
|
3201 |
cdc: 09 c0 rjmp .+18 ; 0xcf0
|
|
|
3202 |
}
|
|
|
3203 |
else
|
|
|
3204 |
{
|
|
|
3205 |
/* generate the stop condition if needed */
|
|
|
3206 |
TWCR |= (1<<TWSTO)|(1<<TWINT);
|
|
|
3207 |
status &= ~(1<<BUSY);
|
|
|
3208 |
}
|
|
|
3209 |
break;
|
|
|
3210 |
|
|
|
3211 |
case TW_MT_DATA_NACK: /* Slave didn't acknowledge data */
|
|
|
3212 |
/* send the stop condition */
|
|
|
3213 |
TWCR |= (1<<TWINT)|(1<<TWSTO);
|
|
|
3214 |
status &= ~(1<<BUSY);
|
|
|
3215 |
break;
|
|
|
3216 |
|
|
|
3217 |
case TW_MR_SLA_ACK: /* Slave acknowledged address */
|
|
|
3218 |
if(--twi_bytes > 0)
|
|
|
3219 |
cde: 80 91 07 01 lds r24, 0x0107
|
|
|
3220 |
ce2: 81 50 subi r24, 0x01 ; 1
|
|
|
3221 |
ce4: 80 93 07 01 sts 0x0107, r24
|
|
|
3222 |
ce8: 80 91 07 01 lds r24, 0x0107
|
|
|
3223 |
cec: 88 23 and r24, r24
|
|
|
3224 |
cee: d9 f4 brne .+54 ; 0xd26
|
|
|
3225 |
{
|
|
|
3226 |
/* if there is more than one byte to read, acknowledge */
|
|
|
3227 |
TWCR |= (1<<TWEA)|(1<<TWINT);
|
|
|
3228 |
}
|
|
|
3229 |
else
|
|
|
3230 |
{
|
|
|
3231 |
/* no acknowledge */
|
|
|
3232 |
TWCR |= (1<<TWINT);
|
|
|
3233 |
cf0: 86 b7 in r24, 0x36 ; 54
|
|
|
3234 |
cf2: 80 68 ori r24, 0x80 ; 128
|
|
|
3235 |
cf4: 1d c0 rjmp .+58 ; 0xd30
|
|
|
3236 |
}
|
|
|
3237 |
break;
|
|
|
3238 |
|
|
|
3239 |
case TW_MR_DATA_ACK: /* Master acknowledged data */
|
|
|
3240 |
|
|
|
3241 |
/* grab the received data */
|
|
|
3242 |
*twi_data = TWDR;
|
|
|
3243 |
cf6: e0 91 04 01 lds r30, 0x0104
|
|
|
3244 |
cfa: f0 91 05 01 lds r31, 0x0105
|
|
|
3245 |
cfe: 83 b1 in r24, 0x03 ; 3
|
|
|
3246 |
d00: 80 83 st Z, r24
|
|
|
3247 |
twi_data++;
|
|
|
3248 |
d02: 80 91 04 01 lds r24, 0x0104
|
|
|
3249 |
d06: 90 91 05 01 lds r25, 0x0105
|
|
|
3250 |
d0a: 01 96 adiw r24, 0x01 ; 1
|
|
|
3251 |
d0c: 90 93 05 01 sts 0x0105, r25
|
|
|
3252 |
d10: 80 93 04 01 sts 0x0104, r24
|
|
|
3253 |
if(--twi_bytes > 0)
|
|
|
3254 |
d14: 80 91 07 01 lds r24, 0x0107
|
|
|
3255 |
d18: 81 50 subi r24, 0x01 ; 1
|
|
|
3256 |
d1a: 80 93 07 01 sts 0x0107, r24
|
|
|
3257 |
d1e: 80 91 07 01 lds r24, 0x0107
|
|
|
3258 |
d22: 88 23 and r24, r24
|
|
|
3259 |
d24: 19 f0 breq .+6 ; 0xd2c
|
|
|
3260 |
{
|
|
|
3261 |
/* get the next data byte and ack */
|
|
|
3262 |
TWCR |= (1<<TWEA)|(1<<TWINT);
|
|
|
3263 |
d26: 86 b7 in r24, 0x36 ; 54
|
|
|
3264 |
d28: 80 6c ori r24, 0xC0 ; 192
|
|
|
3265 |
d2a: 02 c0 rjmp .+4 ; 0xd30
|
|
|
3266 |
}
|
|
|
3267 |
else
|
|
|
3268 |
{
|
|
|
3269 |
/* clear out the enable acknowledge bit */
|
|
|
3270 |
TWCR &= ~(1<<TWEA);
|
|
|
3271 |
d2c: 86 b7 in r24, 0x36 ; 54
|
|
|
3272 |
d2e: 8f 7b andi r24, 0xBF ; 191
|
|
|
3273 |
d30: 86 bf out 0x36, r24 ; 54
|
|
|
3274 |
}
|
|
|
3275 |
break;
|
|
|
3276 |
d32: 0e c0 rjmp .+28 ; 0xd50
|
|
|
3277 |
|
|
|
3278 |
case TW_MR_DATA_NACK: /* Master didn't acknowledge data -> end of read process */
|
|
|
3279 |
/* read data, and generate the stop condition */
|
|
|
3280 |
*twi_data = TWDR;
|
|
|
3281 |
d34: e0 91 04 01 lds r30, 0x0104
|
|
|
3282 |
d38: f0 91 05 01 lds r31, 0x0105
|
|
|
3283 |
d3c: 83 b1 in r24, 0x03 ; 3
|
|
|
3284 |
d3e: 80 83 st Z, r24
|
|
|
3285 |
TWCR |= (1<<TWSTO)|(1<<TWINT);
|
|
|
3286 |
d40: 86 b7 in r24, 0x36 ; 54
|
|
|
3287 |
d42: 80 69 ori r24, 0x90 ; 144
|
|
|
3288 |
d44: 86 bf out 0x36, r24 ; 54
|
|
|
3289 |
status &= ~(1<<BUSY);
|
|
|
3290 |
d46: 80 91 08 01 lds r24, 0x0108
|
|
|
3291 |
d4a: 8f 77 andi r24, 0x7F ; 127
|
|
|
3292 |
d4c: 80 93 08 01 sts 0x0108, r24
|
|
|
3293 |
break;
|
|
|
3294 |
}
|
|
|
3295 |
}
|
|
|
3296 |
d50: ff 91 pop r31
|
|
|
3297 |
d52: ef 91 pop r30
|
|
|
3298 |
d54: bf 91 pop r27
|
|
|
3299 |
d56: af 91 pop r26
|
|
|
3300 |
d58: 9f 91 pop r25
|
|
|
3301 |
d5a: 8f 91 pop r24
|
|
|
3302 |
d5c: 0f 90 pop r0
|
|
|
3303 |
d5e: 0f be out 0x3f, r0 ; 63
|
|
|
3304 |
d60: 0f 90 pop r0
|
|
|
3305 |
d62: 1f 90 pop r1
|
|
|
3306 |
d64: 18 95 reti
|
|
|
3307 |
|
|
|
3308 |
00000d66 <CamConfig_init>:
|
|
|
3309 |
Outputs: none
|
|
|
3310 |
***********************************************************/
|
|
|
3311 |
void CamConfig_init(void)
|
|
|
3312 |
{
|
|
|
3313 |
CamConfig_setCamReg(0x14,0x20); /* reduce frame size */
|
|
|
3314 |
d66: 60 e2 ldi r22, 0x20 ; 32
|
|
|
3315 |
d68: 84 e1 ldi r24, 0x14 ; 20
|
|
|
3316 |
d6a: 0e d0 rcall .+28 ; 0xd88
|
|
|
3317 |
CamConfig_setCamReg(0x39,0x40); /* gate PCLK with HREF */
|
|
|
3318 |
d6c: 60 e4 ldi r22, 0x40 ; 64
|
|
|
3319 |
d6e: 89 e3 ldi r24, 0x39 ; 57
|
|
|
3320 |
d70: 0b d0 rcall .+22 ; 0xd88
|
|
|
3321 |
CamConfig_setCamReg(0x12,0x28); /* set RGB mode, with no AWB */
|
|
|
3322 |
d72: 68 e2 ldi r22, 0x28 ; 40
|
|
|
3323 |
d74: 82 e1 ldi r24, 0x12 ; 18
|
|
|
3324 |
d76: 08 d0 rcall .+16 ; 0xd88
|
|
|
3325 |
CamConfig_setCamReg(0x28,0x05); /* set color sequencer */
|
|
|
3326 |
d78: 65 e0 ldi r22, 0x05 ; 5
|
|
|
3327 |
d7a: 88 e2 ldi r24, 0x28 ; 40
|
|
|
3328 |
d7c: 05 d0 rcall .+10 ; 0xd88
|
|
|
3329 |
CamConfig_setCamReg(0x13,0x01); /* un-tri-state the Y/UV lines */
|
|
|
3330 |
d7e: 61 e0 ldi r22, 0x01 ; 1
|
|
|
3331 |
d80: 83 e1 ldi r24, 0x13 ; 19
|
|
|
3332 |
d82: 02 d0 rcall .+4 ; 0xd88
|
|
|
3333 |
|
|
|
3334 |
/* send the first four cmds in the I2C fifo */
|
|
|
3335 |
CamConfig_sendFifoCmds();
|
|
|
3336 |
d84: 06 d0 rcall .+12 ; 0xd92
|
|
|
3337 |
}
|
|
|
3338 |
d86: 08 95 ret
|
|
|
3339 |
|
|
|
3340 |
00000d88 <CamConfig_setCamReg>:
|
|
|
3341 |
|
|
|
3342 |
|
|
|
3343 |
/***********************************************************
|
|
|
3344 |
Function Name: CamConfig_setCamReg
|
|
|
3345 |
Function Description: This function is responsible for
|
|
|
3346 |
creating an I2C cmd structure and placing it into the
|
|
|
3347 |
cmd fifo.
|
|
|
3348 |
Inputs: reg - the register to modify
|
|
|
3349 |
val - the new value of the register
|
|
|
3350 |
Outputs: none
|
|
|
3351 |
***********************************************************/
|
|
|
3352 |
void CamConfig_setCamReg(unsigned char reg, unsigned char val)
|
|
|
3353 |
{
|
|
|
3354 |
i2cCmd_t cmd;
|
|
|
3355 |
|
|
|
3356 |
cmd.configReg = reg;
|
|
|
3357 |
d88: 28 2f mov r18, r24
|
|
|
3358 |
cmd.data = val;
|
|
|
3359 |
d8a: 36 2f mov r19, r22
|
|
|
3360 |
#ifndef SIMULATION
|
|
|
3361 |
CamConfig_writeTxFifo(cmd);
|
|
|
3362 |
d8c: c9 01 movw r24, r18
|
|
|
3363 |
d8e: 2f d0 rcall .+94 ; 0xdee
|
|
|
3364 |
#endif
|
|
|
3365 |
}
|
|
|
3366 |
d90: 08 95 ret
|
|
|
3367 |
|
|
|
3368 |
00000d92 <CamConfig_sendFifoCmds>:
|
|
|
3369 |
/***********************************************************
|
|
|
3370 |
Function Name: CamConfig_sendFifoCmds
|
|
|
3371 |
Function Description: This function is responsible for
|
|
|
3372 |
sending the entire contents of the config fifo. This
|
|
|
3373 |
function won't return until the configuration process
|
|
|
3374 |
is complete (or an error is encountered).
|
|
|
3375 |
Inputs: none
|
|
|
3376 |
Outputs: none
|
|
|
3377 |
Note: Since this function is written to use the TWI
|
|
|
3378 |
interrupt in the I2CInterface module, there will be
|
|
|
3379 |
some busy-waiting here...no big deal, since we end up
|
|
|
3380 |
having to trash the frame that we are executing this
|
|
|
3381 |
slave write in anyway (since we can't meet the strict
|
|
|
3382 |
timing requirements and write i2c at the same time).
|
|
|
3383 |
***********************************************************/
|
|
|
3384 |
void CamConfig_sendFifoCmds(void)
|
|
|
3385 |
{
|
|
|
3386 |
d92: cf 93 push r28
|
|
|
3387 |
d94: df 93 push r29
|
|
|
3388 |
d96: cd b7 in r28, 0x3d ; 61
|
|
|
3389 |
d98: de b7 in r29, 0x3e ; 62
|
|
|
3390 |
d9a: 22 97 sbiw r28, 0x02 ; 2
|
|
|
3391 |
d9c: 0f b6 in r0, 0x3f ; 63
|
|
|
3392 |
d9e: f8 94 cli
|
|
|
3393 |
da0: de bf out 0x3e, r29 ; 62
|
|
|
3394 |
da2: 0f be out 0x3f, r0 ; 63
|
|
|
3395 |
da4: cd bf out 0x3d, r28 ; 61
|
|
|
3396 |
i2cCmd_t cmd;
|
|
|
3397 |
|
|
|
3398 |
while (CamConfig_txFifoHead != CamConfig_txFifoTail)
|
|
|
3399 |
da6: 90 91 0a 01 lds r25, 0x010A
|
|
|
3400 |
daa: 80 91 0b 01 lds r24, 0x010B
|
|
|
3401 |
dae: 98 17 cp r25, r24
|
|
|
3402 |
db0: a9 f0 breq .+42 ; 0xddc
|
|
|
3403 |
{
|
|
|
3404 |
cmd = CamConfig_readTxFifo();
|
|
|
3405 |
db2: 37 d0 rcall .+110 ; 0xe22
|
|
|
3406 |
db4: 89 83 std Y+1, r24 ; 0x01
|
|
|
3407 |
db6: 9a 83 std Y+2, r25 ; 0x02
|
|
|
3408 |
I2CInt_writeData(CAM_ADDRESS,&cmd.configReg,SIZE_OF_I2C_CMD);
|
|
|
3409 |
db8: 42 e0 ldi r20, 0x02 ; 2
|
|
|
3410 |
dba: be 01 movw r22, r28
|
|
|
3411 |
dbc: 6f 5f subi r22, 0xFF ; 255
|
|
|
3412 |
dbe: 7f 4f sbci r23, 0xFF ; 255
|
|
|
3413 |
dc0: 80 e6 ldi r24, 0x60 ; 96
|
|
|
3414 |
dc2: 04 df rcall .-504 ; 0xbcc
|
|
|
3415 |
Utility_delay(100);
|
|
|
3416 |
dc4: 84 e6 ldi r24, 0x64 ; 100
|
|
|
3417 |
dc6: 90 e0 ldi r25, 0x00 ; 0
|
|
|
3418 |
dc8: 3e d0 rcall .+124 ; 0xe46
|
|
|
3419 |
/* wait for the I2C transaction to complete */
|
|
|
3420 |
while(I2CInt_isI2cBusy() == TRUE);
|
|
|
3421 |
dca: 36 df rcall .-404 ; 0xc38
|
|
|
3422 |
dcc: 81 30 cpi r24, 0x01 ; 1
|
|
|
3423 |
dce: e9 f3 breq .-6 ; 0xdca
|
|
|
3424 |
dd0: 90 91 0a 01 lds r25, 0x010A
|
|
|
3425 |
dd4: 80 91 0b 01 lds r24, 0x010B
|
|
|
3426 |
dd8: 98 17 cp r25, r24
|
|
|
3427 |
dda: 59 f7 brne .-42 ; 0xdb2
|
|
|
3428 |
}
|
|
|
3429 |
}
|
|
|
3430 |
ddc: 22 96 adiw r28, 0x02 ; 2
|
|
|
3431 |
dde: 0f b6 in r0, 0x3f ; 63
|
|
|
3432 |
de0: f8 94 cli
|
|
|
3433 |
de2: de bf out 0x3e, r29 ; 62
|
|
|
3434 |
de4: 0f be out 0x3f, r0 ; 63
|
|
|
3435 |
de6: cd bf out 0x3d, r28 ; 61
|
|
|
3436 |
de8: df 91 pop r29
|
|
|
3437 |
dea: cf 91 pop r28
|
|
|
3438 |
dec: 08 95 ret
|
|
|
3439 |
|
|
|
3440 |
00000dee <CamConfig_writeTxFifo>:
|
|
|
3441 |
|
|
|
3442 |
/***********************************************************
|
|
|
3443 |
Function Name: CamConfig_writeTxFifo
|
|
|
3444 |
Function Description: This function is responsible for
|
|
|
3445 |
adding a new command to the tx fifo. It adjusts all
|
|
|
3446 |
needed pointers.
|
|
|
3447 |
Inputs: cmd - the i2cCmd_t to add to the fifo
|
|
|
3448 |
Outputs: bool_t - indicating if writing to the fifo
|
|
|
3449 |
causes it to wrap
|
|
|
3450 |
***********************************************************/
|
|
|
3451 |
bool_t CamConfig_writeTxFifo(i2cCmd_t cmd)
|
|
|
3452 |
{
|
|
|
3453 |
dee: 9c 01 movw r18, r24
|
|
|
3454 |
unsigned char tmpHead;
|
|
|
3455 |
bool_t retVal = TRUE;
|
|
|
3456 |
df0: 51 e0 ldi r21, 0x01 ; 1
|
|
|
3457 |
|
|
|
3458 |
CamConfig_txFifo[CamConfig_txFifoHead] = cmd;
|
|
|
3459 |
df2: 40 91 0a 01 lds r20, 0x010A
|
|
|
3460 |
df6: 84 2f mov r24, r20
|
|
|
3461 |
df8: 99 27 eor r25, r25
|
|
|
3462 |
dfa: 88 0f add r24, r24
|
|
|
3463 |
dfc: 99 1f adc r25, r25
|
|
|
3464 |
dfe: fc 01 movw r30, r24
|
|
|
3465 |
e00: ec 52 subi r30, 0x2C ; 44
|
|
|
3466 |
e02: fd 4f sbci r31, 0xFD ; 253
|
|
|
3467 |
e04: 20 83 st Z, r18
|
|
|
3468 |
e06: 31 83 std Z+1, r19 ; 0x01
|
|
|
3469 |
|
|
|
3470 |
/* see if we need to wrap */
|
|
|
3471 |
tmpHead = (CamConfig_txFifoHead+1) & (CAM_CONFIG_TX_FIFO_MASK);
|
|
|
3472 |
e08: 84 2f mov r24, r20
|
|
|
3473 |
e0a: 85 0f add r24, r21
|
|
|
3474 |
e0c: 87 70 andi r24, 0x07 ; 7
|
|
|
3475 |
CamConfig_txFifoHead = tmpHead;
|
|
|
3476 |
e0e: 80 93 0a 01 sts 0x010A, r24
|
|
|
3477 |
|
|
|
3478 |
/* check to see if we have filled up the queue */
|
|
|
3479 |
if (CamConfig_txFifoHead == CamConfig_txFifoTail)
|
|
|
3480 |
e12: 90 91 0b 01 lds r25, 0x010B
|
|
|
3481 |
e16: 89 17 cp r24, r25
|
|
|
3482 |
e18: 09 f4 brne .+2 ; 0xe1c
|
|
|
3483 |
{
|
|
|
3484 |
/* we wrapped the fifo...return false */
|
|
|
3485 |
retVal = FALSE;
|
|
|
3486 |
e1a: 50 e0 ldi r21, 0x00 ; 0
|
|
|
3487 |
}
|
|
|
3488 |
return(retVal);
|
|
|
3489 |
e1c: 85 2f mov r24, r21
|
|
|
3490 |
e1e: 99 27 eor r25, r25
|
|
|
3491 |
}
|
|
|
3492 |
e20: 08 95 ret
|
|
|
3493 |
|
|
|
3494 |
00000e22 <CamConfig_readTxFifo>:
|
|
|
3495 |
|
|
|
3496 |
/***********************************************************
|
|
|
3497 |
Function Name: CamConfig_readTxFifo
|
|
|
3498 |
Function Description: This function is responsible for
|
|
|
3499 |
reading a cmd out of the tx fifo.
|
|
|
3500 |
Inputs: none
|
|
|
3501 |
Outputs: i2cCmd_t - the cmd read from the fifo
|
|
|
3502 |
***********************************************************/
|
|
|
3503 |
static i2cCmd_t CamConfig_readTxFifo(void)
|
|
|
3504 |
{
|
|
|
3505 |
i2cCmd_t cmd;
|
|
|
3506 |
unsigned char tmpTail;
|
|
|
3507 |
|
|
|
3508 |
/* just return the current tail from the rx fifo */
|
|
|
3509 |
cmd = CamConfig_txFifo[CamConfig_txFifoTail];
|
|
|
3510 |
e22: 40 91 0b 01 lds r20, 0x010B
|
|
|
3511 |
e26: 84 2f mov r24, r20
|
|
|
3512 |
e28: 99 27 eor r25, r25
|
|
|
3513 |
e2a: 88 0f add r24, r24
|
|
|
3514 |
e2c: 99 1f adc r25, r25
|
|
|
3515 |
e2e: fc 01 movw r30, r24
|
|
|
3516 |
e30: ec 52 subi r30, 0x2C ; 44
|
|
|
3517 |
e32: fd 4f sbci r31, 0xFD ; 253
|
|
|
3518 |
e34: 20 81 ld r18, Z
|
|
|
3519 |
e36: 31 81 ldd r19, Z+1 ; 0x01
|
|
|
3520 |
tmpTail = (CamConfig_txFifoTail+1) & (CAM_CONFIG_TX_FIFO_MASK);
|
|
|
3521 |
e38: 84 2f mov r24, r20
|
|
|
3522 |
e3a: 8f 5f subi r24, 0xFF ; 255
|
|
|
3523 |
e3c: 87 70 andi r24, 0x07 ; 7
|
|
|
3524 |
CamConfig_txFifoTail = tmpTail;
|
|
|
3525 |
e3e: 80 93 0b 01 sts 0x010B, r24
|
|
|
3526 |
|
|
|
3527 |
return(cmd);
|
|
|
3528 |
}
|
|
|
3529 |
e42: c9 01 movw r24, r18
|
|
|
3530 |
e44: 08 95 ret
|
|
|
3531 |
|
|
|
3532 |
00000e46 <Utility_delay>:
|
|
|
3533 |
if needed...this isn't really a millisecond, so DON'T
|
|
|
3534 |
depend on it for exact timing...
|
|
|
3535 |
***********************************************************/
|
|
|
3536 |
void Utility_delay(unsigned short numMs)
|
|
|
3537 |
{
|
|
|
3538 |
e46: cf 93 push r28
|
|
|
3539 |
e48: df 93 push r29
|
|
|
3540 |
e4a: cd b7 in r28, 0x3d ; 61
|
|
|
3541 |
e4c: de b7 in r29, 0x3e ; 62
|
|
|
3542 |
e4e: 24 97 sbiw r28, 0x04 ; 4
|
|
|
3543 |
e50: 0f b6 in r0, 0x3f ; 63
|
|
|
3544 |
e52: f8 94 cli
|
|
|
3545 |
e54: de bf out 0x3e, r29 ; 62
|
|
|
3546 |
e56: 0f be out 0x3f, r0 ; 63
|
|
|
3547 |
e58: cd bf out 0x3d, r28 ; 61
|
|
|
3548 |
e5a: 9c 01 movw r18, r24
|
|
|
3549 |
volatile unsigned short i=0,j=0;
|
|
|
3550 |
e5c: 19 82 std Y+1, r1 ; 0x01
|
|
|
3551 |
e5e: 1a 82 std Y+2, r1 ; 0x02
|
|
|
3552 |
e60: 1b 82 std Y+3, r1 ; 0x03
|
|
|
3553 |
e62: 1c 82 std Y+4, r1 ; 0x04
|
|
|
3554 |
#ifndef SIMULATION
|
|
|
3555 |
for (i=0; i<numMs; i++)
|
|
|
3556 |
e64: 19 82 std Y+1, r1 ; 0x01
|
|
|
3557 |
e66: 1a 82 std Y+2, r1 ; 0x02
|
|
|
3558 |
e68: 89 81 ldd r24, Y+1 ; 0x01
|
|
|
3559 |
e6a: 9a 81 ldd r25, Y+2 ; 0x02
|
|
|
3560 |
e6c: 82 17 cp r24, r18
|
|
|
3561 |
e6e: 93 07 cpc r25, r19
|
|
|
3562 |
e70: e0 f4 brcc .+56 ; 0xeaa
|
|
|
3563 |
{
|
|
|
3564 |
for (j=0; j<1000; j++)
|
|
|
3565 |
e72: 1b 82 std Y+3, r1 ; 0x03
|
|
|
3566 |
e74: 1c 82 std Y+4, r1 ; 0x04
|
|
|
3567 |
e76: 8b 81 ldd r24, Y+3 ; 0x03
|
|
|
3568 |
e78: 9c 81 ldd r25, Y+4 ; 0x04
|
|
|
3569 |
e7a: 88 5e subi r24, 0xE8 ; 232
|
|
|
3570 |
e7c: 93 40 sbci r25, 0x03 ; 3
|
|
|
3571 |
e7e: 58 f4 brcc .+22 ; 0xe96
|
|
|
3572 |
{
|
|
|
3573 |
asm volatile("nop"::);
|
|
|
3574 |
e80: 00 00 nop
|
|
|
3575 |
e82: 8b 81 ldd r24, Y+3 ; 0x03
|
|
|
3576 |
e84: 9c 81 ldd r25, Y+4 ; 0x04
|
|
|
3577 |
e86: 01 96 adiw r24, 0x01 ; 1
|
|
|
3578 |
e88: 8b 83 std Y+3, r24 ; 0x03
|
|
|
3579 |
e8a: 9c 83 std Y+4, r25 ; 0x04
|
|
|
3580 |
e8c: 8b 81 ldd r24, Y+3 ; 0x03
|
|
|
3581 |
e8e: 9c 81 ldd r25, Y+4 ; 0x04
|
|
|
3582 |
e90: 88 5e subi r24, 0xE8 ; 232
|
|
|
3583 |
e92: 93 40 sbci r25, 0x03 ; 3
|
|
|
3584 |
e94: a8 f3 brcs .-22 ; 0xe80
|
|
|
3585 |
e96: 89 81 ldd r24, Y+1 ; 0x01
|
|
|
3586 |
e98: 9a 81 ldd r25, Y+2 ; 0x02
|
|
|
3587 |
e9a: 01 96 adiw r24, 0x01 ; 1
|
|
|
3588 |
e9c: 89 83 std Y+1, r24 ; 0x01
|
|
|
3589 |
e9e: 9a 83 std Y+2, r25 ; 0x02
|
|
|
3590 |
ea0: 89 81 ldd r24, Y+1 ; 0x01
|
|
|
3591 |
ea2: 9a 81 ldd r25, Y+2 ; 0x02
|
|
|
3592 |
ea4: 82 17 cp r24, r18
|
|
|
3593 |
ea6: 93 07 cpc r25, r19
|
|
|
3594 |
ea8: 20 f3 brcs .-56 ; 0xe72
|
|
|
3595 |
}
|
|
|
3596 |
}
|
|
|
3597 |
#endif
|
|
|
3598 |
}
|
|
|
3599 |
eaa: 24 96 adiw r28, 0x04 ; 4
|
|
|
3600 |
eac: 0f b6 in r0, 0x3f ; 63
|
|
|
3601 |
eae: f8 94 cli
|
|
|
3602 |
eb0: de bf out 0x3e, r29 ; 62
|
|
|
3603 |
eb2: 0f be out 0x3f, r0 ; 63
|
|
|
3604 |
eb4: cd bf out 0x3d, r28 ; 61
|
|
|
3605 |
eb6: df 91 pop r29
|
|
|
3606 |
eb8: cf 91 pop r28
|
|
|
3607 |
eba: 08 95 ret
|
|
|
3608 |
|
|
|
3609 |
00000ebc <DebugInt_init>:
|
|
|
3610 |
Inputs: none
|
|
|
3611 |
Outputs: none
|
|
|
3612 |
***********************************************************/
|
|
|
3613 |
void DebugInt_init(void)
|
|
|
3614 |
{
|
|
|
3615 |
ebc: 1f 93 push r17
|
|
|
3616 |
/* set PortD pin6 for output */
|
|
|
3617 |
DDRD |= 0x40;
|
|
|
3618 |
ebe: 8e 9a sbi 0x11, 6 ; 17
|
|
|
3619 |
/* turn on LED */
|
|
|
3620 |
PORTD |= 0x40;
|
|
|
3621 |
ec0: 96 9a sbi 0x12, 6 ; 18
|
|
|
3622 |
Utility_delay(500);
|
|
|
3623 |
ec2: 84 ef ldi r24, 0xF4 ; 244
|
|
|
3624 |
ec4: 91 e0 ldi r25, 0x01 ; 1
|
|
|
3625 |
ec6: bf df rcall .-130 ; 0xe46
|
|
|
3626 |
PORTD &= 0xBF;
|
|
|
3627 |
ec8: 1f eb ldi r17, 0xBF ; 191
|
|
|
3628 |
eca: 82 b3 in r24, 0x12 ; 18
|
|
|
3629 |
ecc: 81 23 and r24, r17
|
|
|
3630 |
ece: 82 bb out 0x12, r24 ; 18
|
|
|
3631 |
Utility_delay(500);
|
|
|
3632 |
ed0: 84 ef ldi r24, 0xF4 ; 244
|
|
|
3633 |
ed2: 91 e0 ldi r25, 0x01 ; 1
|
|
|
3634 |
ed4: b8 df rcall .-144 ; 0xe46
|
|
|
3635 |
PORTD |= 0x40;
|
|
|
3636 |
ed6: 96 9a sbi 0x12, 6 ; 18
|
|
|
3637 |
Utility_delay(500);
|
|
|
3638 |
ed8: 84 ef ldi r24, 0xF4 ; 244
|
|
|
3639 |
eda: 91 e0 ldi r25, 0x01 ; 1
|
|
|
3640 |
edc: b4 df rcall .-152 ; 0xe46
|
|
|
3641 |
PORTD &= 0xBF;
|
|
|
3642 |
ede: 82 b3 in r24, 0x12 ; 18
|
|
|
3643 |
ee0: 81 23 and r24, r17
|
|
|
3644 |
ee2: 82 bb out 0x12, r24 ; 18
|
|
|
3645 |
Utility_delay(500);
|
|
|
3646 |
ee4: 84 ef ldi r24, 0xF4 ; 244
|
|
|
3647 |
ee6: 91 e0 ldi r25, 0x01 ; 1
|
|
|
3648 |
ee8: ae df rcall .-164 ; 0xe46
|
|
|
3649 |
PORTD |= 0x40;
|
|
|
3650 |
eea: 96 9a sbi 0x12, 6 ; 18
|
|
|
3651 |
Utility_delay(500);
|
|
|
3652 |
eec: 84 ef ldi r24, 0xF4 ; 244
|
|
|
3653 |
eee: 91 e0 ldi r25, 0x01 ; 1
|
|
|
3654 |
ef0: aa df rcall .-172 ; 0xe46
|
|
|
3655 |
PORTD &= 0xBF;
|
|
|
3656 |
ef2: 82 b3 in r24, 0x12 ; 18
|
|
|
3657 |
ef4: 81 23 and r24, r17
|
|
|
3658 |
ef6: 82 bb out 0x12, r24 ; 18
|
|
|
3659 |
Utility_delay(500);
|
|
|
3660 |
ef8: 84 ef ldi r24, 0xF4 ; 244
|
|
|
3661 |
efa: 91 e0 ldi r25, 0x01 ; 1
|
|
|
3662 |
efc: a4 df rcall .-184 ; 0xe46
|
|
|
3663 |
PORTD |= 0x40;
|
|
|
3664 |
efe: 96 9a sbi 0x12, 6 ; 18
|
|
|
3665 |
}
|
|
|
3666 |
f00: 1f 91 pop r17
|
|
|
3667 |
f02: 08 95 ret
|
|
|
3668 |
|
|
|
3669 |
00000f04 <CamIntAsm_waitForNewTrackingFrame>:
|
|
|
3670 |
; set, and the function will return.
|
|
|
3671 |
;*****************************************************************
|
|
|
3672 |
|
|
|
3673 |
CamIntAsm_waitForNewTrackingFrame:
|
|
|
3674 |
sbi _SFR_IO_ADDR(PORTD),PD6 ; For testing...
|
|
|
3675 |
f04: 96 9a sbi 0x12, 6 ; 18
|
|
|
3676 |
cbi _SFR_IO_ADDR(PORTD),PD6
|
|
|
3677 |
f06: 96 98 cbi 0x12, 6 ; 18
|
|
|
3678 |
sleep
|
|
|
3679 |
f08: 88 95 sleep
|
|
|
3680 |
|
|
|
3681 |
00000f0a <CamIntAsm_acquireTrackingLine>:
|
|
|
3682 |
|
|
|
3683 |
;*****************************************************************
|
|
|
3684 |
; REMEMBER...everything from here on out is critically timed to be
|
|
|
3685 |
; synchronized with the flow of pixel data from the camera...
|
|
|
3686 |
;*****************************************************************
|
|
|
3687 |
|
|
|
3688 |
CamIntAsm_acquireTrackingLine:
|
|
|
3689 |
brts _cleanUp
|
|
|
3690 |
f0a: e6 f1 brts .+120 ; 0xf84
|
|
|
3691 |
;sbi _SFR_IO_ADDR(PORTD),PD6 ; For testing...
|
|
|
3692 |
;cbi _SFR_IO_ADDR(PORTD),PD6
|
|
|
3693 |
|
|
|
3694 |
in tmp1,_SFR_IO_ADDR(TCCR1B) ; Enable the PCLK line to actually
|
|
|
3695 |
f0c: 3e b5 in r19, 0x2e ; 46
|
|
|
3696 |
ori tmp1, 0x07 ; feed Timer1
|
|
|
3697 |
f0e: 37 60 ori r19, 0x07 ; 7
|
|
|
3698 |
out _SFR_IO_ADDR(TCCR1B),tmp1
|
|
|
3699 |
f10: 3e bd out 0x2e, r19 ; 46
|
|
|
3700 |
; The line is about to start...
|
|
|
3701 |
ldi pixelCount,0 ; Initialize the RLE stats...
|
|
|
3702 |
f12: 00 e0 ldi r16, 0x00 ; 0
|
|
|
3703 |
ldi pixelRunStart,PIXEL_RUN_START_INITIAL ; Remember, we always calculate
|
|
|
3704 |
f14: 10 e5 ldi r17, 0x50 ; 80
|
|
|
3705 |
; the pixel run length as
|
|
|
3706 |
; TCNT1L - pixelRunStart
|
|
|
3707 |
|
|
|
3708 |
ldi lastColor,0x00 ; clear out the last color before we start
|
|
|
3709 |
f16: 20 e0 ldi r18, 0x00 ; 0
|
|
|
3710 |
|
|
|
3711 |
mov XH,currLineBuffHigh ; Load the pointer to the current line
|
|
|
3712 |
f18: b9 2f mov r27, r25
|
|
|
3713 |
mov XL,currLineBuffLow ; buffer into the X pointer regs
|
|
|
3714 |
f1a: a8 2f mov r26, r24
|
|
|
3715 |
|
|
|
3716 |
mov ZH,colorMapHigh ; Load the pointers to the membership
|
|
|
3717 |
f1c: f7 2f mov r31, r23
|
|
|
3718 |
mov ZL,colorMapLow ; lookup tables (ZL and YL will be overwritten
|
|
|
3719 |
f1e: e6 2f mov r30, r22
|
|
|
3720 |
mov YH,colorMapHigh ; as soon as we start reading data) to Z and Y
|
|
|
3721 |
f20: d7 2f mov r29, r23
|
|
|
3722 |
|
|
|
3723 |
in tmp1, _SFR_IO_ADDR(TIMSK) ; enable TIMER1 to start counting
|
|
|
3724 |
f22: 39 b7 in r19, 0x39 ; 57
|
|
|
3725 |
ori tmp1, ENABLE_PCLK_TIMER1_OVERFLOW_BITMASK ; external PCLK pulses and interrupt on
|
|
|
3726 |
f24: 34 60 ori r19, 0x04 ; 4
|
|
|
3727 |
out _SFR_IO_ADDR(TIMSK),tmp1 ; overflow
|
|
|
3728 |
f26: 39 bf out 0x39, r19 ; 57
|
|
|
3729 |
|
|
|
3730 |
ldi tmp1,PIXEL_RUN_START_INITIAL ; set up the TCNT1 to overflow (and
|
|
|
3731 |
f28: 30 e5 ldi r19, 0x50 ; 80
|
|
|
3732 |
ldi tmp2,0xFF ; interrupts) after 176 pixels
|
|
|
3733 |
f2a: 4f ef ldi r20, 0xFF ; 255
|
|
|
3734 |
out _SFR_IO_ADDR(TCNT1H),tmp2
|
|
|
3735 |
f2c: 4d bd out 0x2d, r20 ; 45
|
|
|
3736 |
out _SFR_IO_ADDR(TCNT1L),tmp1
|
|
|
3737 |
f2e: 3c bd out 0x2c, r19 ; 44
|
|
|
3738 |
|
|
|
3739 |
mov YL,colorMapLow
|
|
|
3740 |
f30: c6 2f mov r28, r22
|
|
|
3741 |
|
|
|
3742 |
in tmp1, _SFR_IO_ADDR(GICR) ; enable the HREF interrupt...remember, we
|
|
|
3743 |
f32: 3b b7 in r19, 0x3b ; 59
|
|
|
3744 |
; only use this interrupt to synchronize
|
|
|
3745 |
; the beginning of the line
|
|
|
3746 |
ori tmp1, HREF_INTERRUPT_ENABLE_MASK
|
|
|
3747 |
f34: 30 68 ori r19, 0x80 ; 128
|
|
|
3748 |
out _SFR_IO_ADDR(GICR), tmp1
|
|
|
3749 |
f36: 3b bf out 0x3b, r19 ; 59
|
|
|
3750 |
|
|
|
3751 |
00000f38 <_trackFrame>:
|
|
|
3752 |
|
|
|
3753 |
;*******************************************************************************************
|
|
|
3754 |
; Track Frame handler
|
|
|
3755 |
;*******************************************************************************************
|
|
|
3756 |
|
|
|
3757 |
_trackFrame:
|
|
|
3758 |
sbi _SFR_IO_ADDR(PORTD),PD6
|
|
|
3759 |
f38: 96 9a sbi 0x12, 6 ; 18
|
|
|
3760 |
sleep ; ...And we wait...
|
|
|
3761 |
f3a: 88 95 sleep
|
|
|
3762 |
|
|
|
3763 |
; Returning from the interrupt/sleep wakeup will consume
|
|
|
3764 |
; 14 clock cycles (7 to wakeup from idle sleep, 3 to vector, and 4 to return)
|
|
|
3765 |
|
|
|
3766 |
; Disable the HREF interrupt
|
|
|
3767 |
cbi _SFR_IO_ADDR(PORTD),PD6
|
|
|
3768 |
f3c: 96 98 cbi 0x12, 6 ; 18
|
|
|
3769 |
in tmp1, _SFR_IO_ADDR(GICR)
|
|
|
3770 |
f3e: 3b b7 in r19, 0x3b ; 59
|
|
|
3771 |
andi tmp1, HREF_INTERRUPT_DISABLE_MASK
|
|
|
3772 |
f40: 3f 77 andi r19, 0x7F ; 127
|
|
|
3773 |
out _SFR_IO_ADDR(GICR), tmp1
|
|
|
3774 |
f42: 3b bf out 0x3b, r19 ; 59
|
|
|
3775 |
|
|
|
3776 |
; A couple of NOPs are needed here to sync up the pixel data...the number (2)
|
|
|
3777 |
; of NOPs was determined emperically by trial and error.
|
|
|
3778 |
nop
|
|
|
3779 |
f44: 00 00 nop
|
|
|
3780 |
...
|
|
|
3781 |
|
|
|
3782 |
00000f48 <_acquirePixelBlock>:
|
|
|
3783 |
nop
|
|
|
3784 |
_acquirePixelBlock: ; Clock Cycle Count
|
|
|
3785 |
in ZL,RB_PORT ; sample the red value (PINB) (1)
|
|
|
3786 |
f48: e6 b3 in r30, 0x16 ; 22
|
|
|
3787 |
in YL,G_PORT ; sample the green value (PINC) (1)
|
|
|
3788 |
f4a: c3 b3 in r28, 0x13 ; 19
|
|
|
3789 |
andi YL,0x0F ; clear the high nibble (1)
|
|
|
3790 |
f4c: cf 70 andi r28, 0x0F ; 15
|
|
|
3791 |
ldd color,Z+RED_MEM_OFFSET ; lookup the red membership (2)
|
|
|
3792 |
f4e: 30 81 ld r19, Z
|
|
|
3793 |
in ZL,RB_PORT ; sample the blue value (PINB) (1)
|
|
|
3794 |
f50: e6 b3 in r30, 0x16 ; 22
|
|
|
3795 |
ldd greenData,Y+GREEN_MEM_OFFSET; lookup the green membership (2)
|
|
|
3796 |
f52: 48 89 ldd r20, Y+16 ; 0x10
|
|
|
3797 |
ldd blueData,Z+BLUE_MEM_OFFSET ; lookup the blue membership (2)
|
|
|
3798 |
f54: 50 a1 ldd r21, Z+32 ; 0x20
|
|
|
3799 |
and color,greenData ; mask memberships together (1)
|
|
|
3800 |
f56: 34 23 and r19, r20
|
|
|
3801 |
and color,blueData ; to produce the final color (1)
|
|
|
3802 |
f58: 35 23 and r19, r21
|
|
|
3803 |
brts _cleanUpTrackingLine ; if some interrupt routine has (1...not set)
|
|
|
3804 |
f5a: 76 f0 brts .+28 ; 0xf78
|
|
|
3805 |
; come in and set our T flag in
|
|
|
3806 |
; SREG, then we need to hop out
|
|
|
3807 |
; and blow away this frames data (common cleanup)
|
|
|
3808 |
cp color,lastColor ; check to see if the run continues (1)
|
|
|
3809 |
f5c: 32 17 cp r19, r18
|
|
|
3810 |
breq _acquirePixelBlock ; (2...equal)
|
|
|
3811 |
f5e: a1 f3 breq .-24 ; 0xf48
|
|
|
3812 |
; ___________
|
|
|
3813 |
; 16 clock cycles
|
|
|
3814 |
; (16 clock cycles = 1 uS = 1 pixelBlock time)
|
|
|
3815 |
|
|
|
3816 |
; Toggle the debug line to indicate a color change
|
|
|
3817 |
sbi _SFR_IO_ADDR(PORTD),PD6
|
|
|
3818 |
f60: 96 9a sbi 0x12, 6 ; 18
|
|
|
3819 |
nop
|
|
|
3820 |
f62: 00 00 nop
|
|
|
3821 |
cbi _SFR_IO_ADDR(PORTD),PD6
|
|
|
3822 |
f64: 96 98 cbi 0x12, 6 ; 18
|
|
|
3823 |
|
|
|
3824 |
mov tmp2,pixelRunStart ; get the count value of the
|
|
|
3825 |
f66: 41 2f mov r20, r17
|
|
|
3826 |
; current pixel run
|
|
|
3827 |
in pixelCount,_SFR_IO_ADDR(TCNT1L) ; get the current TCNT1 value
|
|
|
3828 |
f68: 0c b5 in r16, 0x2c ; 44
|
|
|
3829 |
mov pixelRunStart,pixelCount ; reload pixelRunStart for the
|
|
|
3830 |
f6a: 10 2f mov r17, r16
|
|
|
3831 |
; next run
|
|
|
3832 |
sub pixelCount,tmp2 ; pixelCount = TCNT1L - pixelRunStart
|
|
|
3833 |
f6c: 04 1b sub r16, r20
|
|
|
3834 |
|
|
|
3835 |
st X+,lastColor ; record the color run in the current line buffer
|
|
|
3836 |
f6e: 2d 93 st X+, r18
|
|
|
3837 |
st X+,pixelCount ; with its length
|
|
|
3838 |
f70: 0d 93 st X+, r16
|
|
|
3839 |
mov lastColor,color ; set lastColor so we can figure out when it changes
|
|
|
3840 |
f72: 23 2f mov r18, r19
|
|
|
3841 |
|
|
|
3842 |
nop ; waste one more cycle for a total of 16
|
|
|
3843 |
f74: 00 00 nop
|
|
|
3844 |
rjmp _acquirePixelBlock
|
|
|
3845 |
f76: e8 cf rjmp .-48 ; 0xf48
|
|
|
3846 |
|
|
|
3847 |
00000f78 <_cleanUpTrackingLine>:
|
|
|
3848 |
|
|
|
3849 |
; _cleanUpTrackingLine is used to write the last run length block off to the currentLineBuffer so
|
|
|
3850 |
; that all 176 pixels in the line are accounted for.
|
|
|
3851 |
_cleanUpTrackingLine:
|
|
|
3852 |
ldi pixelCount,0xFF ; the length of the last run is ALWAYS 0xFF minus the last
|
|
|
3853 |
f78: 0f ef ldi r16, 0xFF ; 255
|
|
|
3854 |
sub pixelCount,pixelRunStart ; pixelRunStart
|
|
|
3855 |
f7a: 01 1b sub r16, r17
|
|
|
3856 |
|
|
|
3857 |
inc pixelCount ; increment pixelCount since we actually need to account
|
|
|
3858 |
f7c: 03 95 inc r16
|
|
|
3859 |
; for the overflow of TCNT1
|
|
|
3860 |
|
|
|
3861 |
st X+,color ; record the color run in the current line buffer
|
|
|
3862 |
f7e: 3d 93 st X+, r19
|
|
|
3863 |
st X,pixelCount
|
|
|
3864 |
f80: 0c 93 st X, r16
|
|
|
3865 |
rjmp _cleanUp
|
|
|
3866 |
f82: 00 c0 rjmp .+0 ; 0xf84
|
|
|
3867 |
|
|
|
3868 |
00000f84 <_cleanUp>:
|
|
|
3869 |
|
|
|
3870 |
_cleanUpDumpLine:
|
|
|
3871 |
; NOTE: If serial data is received, to interrupt the tracking of a line, we'll
|
|
|
3872 |
; get a EV_SERIAL_DATA_RECEIVED event, and the T bit set so we will end the
|
|
|
3873 |
; line's processing...however, the PCLK will keep on ticking for the rest of
|
|
|
3874 |
; the frame/line, which will cause the TCNT to eventually overflow and
|
|
|
3875 |
; interrupt us, generating a EV_ACQUIRE_LINE_COMPLETE event. We don't want
|
|
|
3876 |
; this, so we need to actually turn off the PCLK counting each time we exit
|
|
|
3877 |
; this loop, and only turn it on when we begin acquiring lines....
|
|
|
3878 |
; NOT NEEDED FOR NOW...
|
|
|
3879 |
;in tmp1, _SFR_IO_ADDR(TIMSK) ; disable TIMER1 to stop counting
|
|
|
3880 |
;andi tmp1, DISABLE_PCLK_TIMER1_OVERFLOW_BITMASK ; external PCLK pulses
|
|
|
3881 |
;out _SFR_IO_ADDR(TIMSK),tmp1
|
|
|
3882 |
|
|
|
3883 |
_cleanUp:
|
|
|
3884 |
; Disable the external clocking of the Timer1 counter
|
|
|
3885 |
in tmp1, _SFR_IO_ADDR(TCCR1B)
|
|
|
3886 |
f84: 3e b5 in r19, 0x2e ; 46
|
|
|
3887 |
andi tmp1, 0xF8
|
|
|
3888 |
f86: 38 7f andi r19, 0xF8 ; 248
|
|
|
3889 |
out _SFR_IO_ADDR(TCCR1B),tmp1
|
|
|
3890 |
f88: 3e bd out 0x2e, r19 ; 46
|
|
|
3891 |
|
|
|
3892 |
; Toggle the debug line to indicate the line is complete
|
|
|
3893 |
sbi _SFR_IO_ADDR(PORTD),PD6
|
|
|
3894 |
f8a: 96 9a sbi 0x12, 6 ; 18
|
|
|
3895 |
cbi _SFR_IO_ADDR(PORTD),PD6
|
|
|
3896 |
f8c: 96 98 cbi 0x12, 6 ; 18
|
|
|
3897 |
clt ; clear out the T bit since we have detected
|
|
|
3898 |
f8e: e8 94 clt
|
|
|
3899 |
|
|
|
3900 |
00000f90 <_exit>:
|
|
|
3901 |
; the interruption and are exiting to handle it
|
|
|
3902 |
_exit:
|
|
|
3903 |
ret
|
|
|
3904 |
f90: 08 95 ret
|
|
|
3905 |
|
|
|
3906 |
00000f92 <CamIntAsm_waitForNewDumpFrame>:
|
|
|
3907 |
|
|
|
3908 |
;*****************************************************************
|
|
|
3909 |
; Function Name: CamIntAsm_waitForNewDumpFrame
|
|
|
3910 |
; Function Description: This function is responsible for
|
|
|
3911 |
; going to sleep until a new frame begins (indicated by
|
|
|
3912 |
; VSYNC transitioning from low to high. This will wake
|
|
|
3913 |
; the "VSYNC sleep" up and allow it to continue with
|
|
|
3914 |
; acquiring a line of pixel data to dump out to the UI.
|
|
|
3915 |
; Inputs: r25 - MSB of currentLineBuffer
|
|
|
3916 |
; r24 - LSB of currentLineBuffer
|
|
|
3917 |
; r23 - MSB of prevLineBuffer
|
|
|
3918 |
; r22 - LSB of prevLineBuffer
|
|
|
3919 |
; Outputs: none
|
|
|
3920 |
; NOTES: This function doesn't really return...it sorta just
|
|
|
3921 |
; floats into the acquireDumpLine function after the "VSYNC sleep"
|
|
|
3922 |
; is awoken.
|
|
|
3923 |
;*****************************************************************
|
|
|
3924 |
CamIntAsm_waitForNewDumpFrame:
|
|
|
3925 |
sbi _SFR_IO_ADDR(PORTD),PD6 ; For testing...
|
|
|
3926 |
f92: 96 9a sbi 0x12, 6 ; 18
|
|
|
3927 |
cbi _SFR_IO_ADDR(PORTD),PD6
|
|
|
3928 |
f94: 96 98 cbi 0x12, 6 ; 18
|
|
|
3929 |
sleep
|
|
|
3930 |
f96: 88 95 sleep
|
|
|
3931 |
|
|
|
3932 |
00000f98 <CamIntAsm_acquireDumpLine>:
|
|
|
3933 |
|
|
|
3934 |
;*****************************************************************
|
|
|
3935 |
; REMEMBER...everything from here on out is critically timed to be
|
|
|
3936 |
; synchronized with the flow of pixel data from the camera...
|
|
|
3937 |
;*****************************************************************
|
|
|
3938 |
|
|
|
3939 |
CamIntAsm_acquireDumpLine:
|
|
|
3940 |
brts _cleanUp
|
|
|
3941 |
f98: ae f3 brts .-22 ; 0xf84
|
|
|
3942 |
;sbi _SFR_IO_ADDR(PORTD),PD6 ; For testing...
|
|
|
3943 |
;cbi _SFR_IO_ADDR(PORTD),PD6
|
|
|
3944 |
|
|
|
3945 |
mov XH,currLineBuffHigh ; Load the pointer to the current line
|
|
|
3946 |
f9a: b9 2f mov r27, r25
|
|
|
3947 |
mov XL,currLineBuffLow ; buffer into the X pointer regs
|
|
|
3948 |
f9c: a8 2f mov r26, r24
|
|
|
3949 |
|
|
|
3950 |
mov YH,prevLineBuffHigh ; Load the pointer to the previous line
|
|
|
3951 |
f9e: d7 2f mov r29, r23
|
|
|
3952 |
mov YL,prevLineBuffLow ; buffer into the Y pointer regs
|
|
|
3953 |
fa0: c6 2f mov r28, r22
|
|
|
3954 |
|
|
|
3955 |
ldi tmp1,PIXEL_RUN_START_INITIAL ; set up the TCNT1 to overflow (and
|
|
|
3956 |
fa2: 30 e5 ldi r19, 0x50 ; 80
|
|
|
3957 |
ldi tmp2,0xFF ; interrupts) after 176 pixels
|
|
|
3958 |
fa4: 4f ef ldi r20, 0xFF ; 255
|
|
|
3959 |
out _SFR_IO_ADDR(TCNT1H),tmp2
|
|
|
3960 |
fa6: 4d bd out 0x2d, r20 ; 45
|
|
|
3961 |
out _SFR_IO_ADDR(TCNT1L),tmp1
|
|
|
3962 |
fa8: 3c bd out 0x2c, r19 ; 44
|
|
|
3963 |
|
|
|
3964 |
in tmp1, _SFR_IO_ADDR(TCCR1B) ; Enable the PCLK line to actually
|
|
|
3965 |
faa: 3e b5 in r19, 0x2e ; 46
|
|
|
3966 |
ori tmp1, 0x07 ; feed Timer1
|
|
|
3967 |
fac: 37 60 ori r19, 0x07 ; 7
|
|
|
3968 |
out _SFR_IO_ADDR(TCCR1B),tmp1
|
|
|
3969 |
fae: 3e bd out 0x2e, r19 ; 46
|
|
|
3970 |
nop
|
|
|
3971 |
fb0: 00 00 nop
|
|
|
3972 |
|
|
|
3973 |
in tmp1, _SFR_IO_ADDR(TIMSK) ; enable TIMER1 to start counting
|
|
|
3974 |
fb2: 39 b7 in r19, 0x39 ; 57
|
|
|
3975 |
ori tmp1, ENABLE_PCLK_TIMER1_OVERFLOW_BITMASK ; external PCLK pulses and interrupt on
|
|
|
3976 |
fb4: 34 60 ori r19, 0x04 ; 4
|
|
|
3977 |
out _SFR_IO_ADDR(TIMSK),tmp1 ; overflow
|
|
|
3978 |
fb6: 39 bf out 0x39, r19 ; 57
|
|
|
3979 |
|
|
|
3980 |
in tmp1, _SFR_IO_ADDR(GICR) ; enable the HREF interrupt...remember, we
|
|
|
3981 |
fb8: 3b b7 in r19, 0x3b ; 59
|
|
|
3982 |
; only use this interrupt to synchronize
|
|
|
3983 |
; the beginning of the line
|
|
|
3984 |
ori tmp1, HREF_INTERRUPT_ENABLE_MASK
|
|
|
3985 |
fba: 30 68 ori r19, 0x80 ; 128
|
|
|
3986 |
out _SFR_IO_ADDR(GICR), tmp1
|
|
|
3987 |
fbc: 3b bf out 0x3b, r19 ; 59
|
|
|
3988 |
|
|
|
3989 |
00000fbe <_dumpFrame>:
|
|
|
3990 |
|
|
|
3991 |
;*******************************************************************************************
|
|
|
3992 |
; Dump Frame handler
|
|
|
3993 |
;*******************************************************************************************
|
|
|
3994 |
|
|
|
3995 |
_dumpFrame:
|
|
|
3996 |
sbi _SFR_IO_ADDR(PORTD),PD6
|
|
|
3997 |
fbe: 96 9a sbi 0x12, 6 ; 18
|
|
|
3998 |
sleep ; ...And we wait...
|
|
|
3999 |
fc0: 88 95 sleep
|
|
|
4000 |
|
|
|
4001 |
cbi _SFR_IO_ADDR(PORTD),PD6
|
|
|
4002 |
fc2: 96 98 cbi 0x12, 6 ; 18
|
|
|
4003 |
in tmp1, _SFR_IO_ADDR(GICR) ; disable the HREF interrupt
|
|
|
4004 |
fc4: 3b b7 in r19, 0x3b ; 59
|
|
|
4005 |
andi tmp1, HREF_INTERRUPT_DISABLE_MASK ; so we don't get interrupted
|
|
|
4006 |
fc6: 3f 77 andi r19, 0x7F ; 127
|
|
|
4007 |
out _SFR_IO_ADDR(GICR), tmp1 ; while dumping the line
|
|
|
4008 |
fc8: 3b bf out 0x3b, r19 ; 59
|
|
|
4009 |
...
|
|
|
4010 |
|
|
|
4011 |
00000fcc <_sampleDumpPixel>:
|
|
|
4012 |
|
|
|
4013 |
nop ; Remember...if we ever remove the "cbi" instruction above,
|
|
|
4014 |
; we need to add two more NOPs to cover this
|
|
|
4015 |
|
|
|
4016 |
; Ok...the following loop needs to run in 8 clock cycles, so we can get every
|
|
|
4017 |
; pixel in the line...this shouldn't be a problem, since the PCLK timing was
|
|
|
4018 |
; reduced by a factor of 2 whenever we go to dump a line (this is to give us
|
|
|
4019 |
; enough time to do the sampling and storing of the pixel data). In addition,
|
|
|
4020 |
; it is assumed that we will have to do some minor processing on the data right
|
|
|
4021 |
; before we send it out, like mask off the top 4-bits of each, and then pack both
|
|
|
4022 |
; low nibbles into a single byte for transmission...we just don't have time to
|
|
|
4023 |
; do that here (only 8 instruction cycles :-) )
|
|
|
4024 |
_sampleDumpPixel:
|
|
|
4025 |
in tmp1,G_PORT ; sample the G value (1)
|
|
|
4026 |
fcc: 33 b3 in r19, 0x13 ; 19
|
|
|
4027 |
in tmp2,RB_PORT ; sample the R/B value (1)
|
|
|
4028 |
fce: 46 b3 in r20, 0x16 ; 22
|
|
|
4029 |
st X+,tmp1 ; store to the currLineBuff and inc ptrs(2)
|
|
|
4030 |
fd0: 3d 93 st X+, r19
|
|
|
4031 |
st Y+,tmp2 ; store to the prevLineBuff and inc ptrs(2)
|
|
|
4032 |
fd2: 49 93 st Y+, r20
|
|
|
4033 |
brtc _sampleDumpPixel ; loop back unless flag is set (2...if not set)
|
|
|
4034 |
fd4: de f7 brtc .-10 ; 0xfcc
|
|
|
4035 |
; ___________
|
|
|
4036 |
; 8 cycles normally
|
|
|
4037 |
|
|
|
4038 |
; if we make it here, it means the T flag is set, and we must have been interrupted
|
|
|
4039 |
; so we need to exit (what if we were interrupted for serial? should we disable it?)
|
|
|
4040 |
rjmp _cleanUpDumpLine
|
|
|
4041 |
fd6: d6 cf rjmp .-84 ; 0xf84
|
|
|
4042 |
|
|
|
4043 |
00000fd8 <__vector_1>:
|
|
|
4044 |
|
|
|
4045 |
;***********************************************************
|
|
|
4046 |
; Function Name: <interrupt handler for External Interrupt0>
|
|
|
4047 |
; Function Description: This function is responsible
|
|
|
4048 |
; for handling a rising edge on the Ext Interrupt 0. This
|
|
|
4049 |
; routine simply returns, since we just want to wake up
|
|
|
4050 |
; whenever the VSYNC transitions (meaning the start of a new
|
|
|
4051 |
; frame).
|
|
|
4052 |
; Inputs: none
|
|
|
4053 |
; Outputs: none
|
|
|
4054 |
;***********************************************************
|
|
|
4055 |
SIG_INTERRUPT0:
|
|
|
4056 |
; This will wake us up when VSYNC transitions high...we just want to return
|
|
|
4057 |
reti
|
|
|
4058 |
fd8: 18 95 reti
|
|
|
4059 |
|
|
|
4060 |
00000fda <__vector_2>:
|
|
|
4061 |
|
|
|
4062 |
;***********************************************************
|
|
|
4063 |
; Function Name: <interrupt handler for External Interrupt1>
|
|
|
4064 |
; Function Description: This function is responsible
|
|
|
4065 |
; for handling a falling edge on the Ext Interrupt 1. This
|
|
|
4066 |
; routine simply returns, since we just want to wake up
|
|
|
4067 |
; whenever the HREF transitions (meaning the pixels
|
|
|
4068 |
; are starting after VSYNC transitioned, and we need to
|
|
|
4069 |
; start acquiring the pixel blocks
|
|
|
4070 |
; Inputs: none
|
|
|
4071 |
; Outputs: none
|
|
|
4072 |
;***********************************************************
|
|
|
4073 |
SIG_INTERRUPT1:
|
|
|
4074 |
; This will wake us up when HREF transitions high...we just want to return
|
|
|
4075 |
reti
|
|
|
4076 |
fda: 18 95 reti
|
|
|
4077 |
|
|
|
4078 |
00000fdc <__vector_8>:
|
|
|
4079 |
|
|
|
4080 |
;***********************************************************
|
|
|
4081 |
; Function Name: <interrupt handler for Timer0 overflow>
|
|
|
4082 |
; Function Description: This function is responsible
|
|
|
4083 |
; for handling the Timer0 overflow (hooked up to indicate
|
|
|
4084 |
; when we have reached the number of HREFs required in a
|
|
|
4085 |
; single frame). We set the T flag in the SREG to
|
|
|
4086 |
; indicate to the _acquirePixelBlock routine that it needs
|
|
|
4087 |
; to exit, and then set the appropriate action to take in
|
|
|
4088 |
; the eventList of the Executive module.
|
|
|
4089 |
; Inputs: none
|
|
|
4090 |
; Outputs: none
|
|
|
4091 |
; Note: Originally, the HREF pulses were also going to
|
|
|
4092 |
; be counted by a hardware counter, but it didn't end up
|
|
|
4093 |
; being necessary
|
|
|
4094 |
;***********************************************************
|
|
|
4095 |
;SIG_OVERFLOW0:
|
|
|
4096 |
; set ; set the T bit in SREG
|
|
|
4097 |
; lds tmp1,eventBitmask
|
|
|
4098 |
; ori tmp1,EV_ACQUIRE_FRAME_COMPLETE
|
|
|
4099 |
; sts eventBitmask,tmp1
|
|
|
4100 |
; reti
|
|
|
4101 |
|
|
|
4102 |
;***********************************************************
|
|
|
4103 |
; Function Name: <interrupt handler for Timer1 overflow>
|
|
|
4104 |
; Function Description: This function is responsible
|
|
|
4105 |
; for handling the Timer1 overflow (hooked up to indicate
|
|
|
4106 |
; when we have reached the end of a line of pixel data,
|
|
|
4107 |
; since PCLK is hooked up to overflow TCNT1 after 176
|
|
|
4108 |
; pixels). This routine generates an acquire line complete
|
|
|
4109 |
; event in the fastEventBitmask, which is streamlined for
|
|
|
4110 |
; efficiency reasons.
|
|
|
4111 |
;***********************************************************
|
|
|
4112 |
SIG_OVERFLOW1:
|
|
|
4113 |
lds tmp1,fastEventBitmask ; set a flag indicating
|
|
|
4114 |
fdc: 30 91 72 00 lds r19, 0x0072
|
|
|
4115 |
ori tmp1,FEV_ACQUIRE_LINE_COMPLETE ; a line is complete
|
|
|
4116 |
fe0: 31 60 ori r19, 0x01 ; 1
|
|
|
4117 |
sts fastEventBitmask,tmp1
|
|
|
4118 |
fe2: 30 93 72 00 sts 0x0072, r19
|
|
|
4119 |
set ; set the T bit in SREG
|
|
|
4120 |
fe6: 68 94 set
|
|
|
4121 |
;sbi _SFR_IO_ADDR(PORTD),PD6 ; For testing...
|
|
|
4122 |
;cbi _SFR_IO_ADDR(PORTD),PD6 ; For testing...
|
|
|
4123 |
|
|
|
4124 |
reti
|
|
|
4125 |
fe8: 18 95 reti
|
|
|
4126 |
|
|
|
4127 |
00000fea <__vector_default>:
|
|
|
4128 |
|
|
|
4129 |
; This is the default handler for all interrupts that don't
|
|
|
4130 |
; have handler routines specified for them.
|
|
|
4131 |
.global __vector_default
|
|
|
4132 |
__vector_default:
|
|
|
4133 |
reti
|
|
|
4134 |
fea: 18 95 reti
|
|
|
4135 |
|
|
|
4136 |
00000fec <atoi>:
|
|
|
4137 |
fec: fc 01 movw r30, r24
|
|
|
4138 |
fee: 88 27 eor r24, r24
|
|
|
4139 |
ff0: 99 27 eor r25, r25
|
|
|
4140 |
ff2: e8 94 clt
|
|
|
4141 |
|
|
|
4142 |
00000ff4 <.atoi_loop>:
|
|
|
4143 |
ff4: 21 91 ld r18, Z+
|
|
|
4144 |
ff6: 22 23 and r18, r18
|
|
|
4145 |
ff8: e9 f0 breq .+58 ; 0x1034
|
|
|
4146 |
ffa: 20 32 cpi r18, 0x20 ; 32
|
|
|
4147 |
ffc: d9 f3 breq .-10 ; 0xff4
|
|
|
4148 |
ffe: 29 30 cpi r18, 0x09 ; 9
|
|
|
4149 |
1000: c9 f3 breq .-14 ; 0xff4
|
|
|
4150 |
1002: 2a 30 cpi r18, 0x0A ; 10
|
|
|
4151 |
1004: b9 f3 breq .-18 ; 0xff4
|
|
|
4152 |
1006: 2c 30 cpi r18, 0x0C ; 12
|
|
|
4153 |
1008: a9 f3 breq .-22 ; 0xff4
|
|
|
4154 |
100a: 2d 30 cpi r18, 0x0D ; 13
|
|
|
4155 |
100c: 99 f3 breq .-26 ; 0xff4
|
|
|
4156 |
100e: 26 37 cpi r18, 0x76 ; 118
|
|
|
4157 |
1010: 89 f3 breq .-30 ; 0xff4
|
|
|
4158 |
1012: 2b 32 cpi r18, 0x2B ; 43
|
|
|
4159 |
1014: 19 f0 breq .+6 ; 0x101c
|
|
|
4160 |
1016: 2d 32 cpi r18, 0x2D ; 45
|
|
|
4161 |
1018: 21 f4 brne .+8 ; 0x1022
|
|
|
4162 |
|
|
|
4163 |
0000101a <.atoi_neg>:
|
|
|
4164 |
101a: 68 94 set
|
|
|
4165 |
|
|
|
4166 |
0000101c <.atoi_loop2>:
|
|
|
4167 |
101c: 21 91 ld r18, Z+
|
|
|
4168 |
101e: 22 23 and r18, r18
|
|
|
4169 |
1020: 49 f0 breq .+18 ; 0x1034
|
|
|
4170 |
|
|
|
4171 |
00001022 <.atoi_digit>:
|
|
|
4172 |
1022: 20 33 cpi r18, 0x30 ; 48
|
|
|
4173 |
1024: 3c f0 brlt .+14 ; 0x1034
|
|
|
4174 |
1026: 2a 33 cpi r18, 0x3A ; 58
|
|
|
4175 |
1028: 2c f4 brge .+10 ; 0x1034
|
|
|
4176 |
102a: 20 53 subi r18, 0x30 ; 48
|
|
|
4177 |
102c: 2f d0 rcall .+94 ; 0x108c
|
|
|
4178 |
102e: 82 0f add r24, r18
|
|
|
4179 |
1030: 91 1d adc r25, r1
|
|
|
4180 |
1032: f4 cf rjmp .-24 ; 0x101c
|
|
|
4181 |
|
|
|
4182 |
00001034 <.atoi_sig>:
|
|
|
4183 |
1034: 81 15 cp r24, r1
|
|
|
4184 |
1036: 91 05 cpc r25, r1
|
|
|
4185 |
1038: 21 f0 breq .+8 ; 0x1042
|
|
|
4186 |
103a: 1e f4 brtc .+6 ; 0x1042
|
|
|
4187 |
103c: 80 95 com r24
|
|
|
4188 |
103e: 90 95 com r25
|
|
|
4189 |
1040: 01 96 adiw r24, 0x01 ; 1
|
|
|
4190 |
|
|
|
4191 |
00001042 <.atoi_done>:
|
|
|
4192 |
1042: 08 95 ret
|
|
|
4193 |
|
|
|
4194 |
00001044 <eeprom_read_byte>:
|
|
|
4195 |
1044: e1 99 sbic 0x1c, 1 ; 28
|
|
|
4196 |
1046: fe cf rjmp .-4 ; 0x1044
|
|
|
4197 |
1048: 9f bb out 0x1f, r25 ; 31
|
|
|
4198 |
104a: 8e bb out 0x1e, r24 ; 30
|
|
|
4199 |
104c: e0 9a sbi 0x1c, 0 ; 28
|
|
|
4200 |
104e: 99 27 eor r25, r25
|
|
|
4201 |
1050: 8d b3 in r24, 0x1d ; 29
|
|
|
4202 |
1052: 08 95 ret
|
|
|
4203 |
|
|
|
4204 |
00001054 <eeprom_read_block>:
|
|
|
4205 |
1054: 41 15 cp r20, r1
|
|
|
4206 |
1056: 51 05 cpc r21, r1
|
|
|
4207 |
1058: 69 f0 breq .+26 ; 0x1074
|
|
|
4208 |
105a: dc 01 movw r26, r24
|
|
|
4209 |
|
|
|
4210 |
0000105c <eeprom_read_block_busy>:
|
|
|
4211 |
105c: e1 99 sbic 0x1c, 1 ; 28
|
|
|
4212 |
105e: fe cf rjmp .-4 ; 0x105c
|
|
|
4213 |
|
|
|
4214 |
00001060 <eeprom_read_block_loop>:
|
|
|
4215 |
1060: 7f bb out 0x1f, r23 ; 31
|
|
|
4216 |
1062: 6e bb out 0x1e, r22 ; 30
|
|
|
4217 |
1064: e0 9a sbi 0x1c, 0 ; 28
|
|
|
4218 |
1066: 6f 5f subi r22, 0xFF ; 255
|
|
|
4219 |
1068: 7f 4f sbci r23, 0xFF ; 255
|
|
|
4220 |
106a: 0d b2 in r0, 0x1d ; 29
|
|
|
4221 |
106c: 0d 92 st X+, r0
|
|
|
4222 |
106e: 41 50 subi r20, 0x01 ; 1
|
|
|
4223 |
1070: 50 40 sbci r21, 0x00 ; 0
|
|
|
4224 |
1072: b1 f7 brne .-20 ; 0x1060
|
|
|
4225 |
|
|
|
4226 |
00001074 <eeprom_read_block_done>:
|
|
|
4227 |
1074: 08 95 ret
|
|
|
4228 |
|
|
|
4229 |
00001076 <eeprom_write_byte>:
|
|
|
4230 |
1076: e1 99 sbic 0x1c, 1 ; 28
|
|
|
4231 |
1078: fe cf rjmp .-4 ; 0x1076
|
|
|
4232 |
107a: 9f bb out 0x1f, r25 ; 31
|
|
|
4233 |
107c: 8e bb out 0x1e, r24 ; 30
|
|
|
4234 |
107e: 6d bb out 0x1d, r22 ; 29
|
|
|
4235 |
1080: 0f b6 in r0, 0x3f ; 63
|
|
|
4236 |
1082: f8 94 cli
|
|
|
4237 |
1084: e2 9a sbi 0x1c, 2 ; 28
|
|
|
4238 |
1086: e1 9a sbi 0x1c, 1 ; 28
|
|
|
4239 |
1088: 0f be out 0x3f, r0 ; 63
|
|
|
4240 |
108a: 08 95 ret
|
|
|
4241 |
|
|
|
4242 |
0000108c <__mulhi_const_10>:
|
|
|
4243 |
108c: 7a e0 ldi r23, 0x0A ; 10
|
|
|
4244 |
108e: 97 9f mul r25, r23
|
|
|
4245 |
1090: 90 2d mov r25, r0
|
|
|
4246 |
1092: 87 9f mul r24, r23
|
|
|
4247 |
1094: 80 2d mov r24, r0
|
|
|
4248 |
1096: 91 0d add r25, r1
|
|
|
4249 |
1098: 11 24 eor r1, r1
|
|
|
4250 |
109a: 08 95 ret
|
|
|
4251 |
|
|
|
4252 |
0000109c <_exit>:
|
|
|
4253 |
109c: ff cf rjmp .-2 ; 0x109c
|