cm/robo-crawler
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
robo-crawler/RoboMI.lss

4644 lines
155 KiB
Plaintext
Raw Blame History

RoboMI.elf: file format elf32-avr
Sections:
Idx Name Size VMA LMA File off Algn
0 .data 0000032a 00800100 0000184a 000018be 2**0
CONTENTS, ALLOC, LOAD, DATA
1 .text 0000184a 00000000 00000000 00000074 2**1
CONTENTS, ALLOC, LOAD, READONLY, CODE
2 .bss 0000003b 0080042a 00001b74 00001be8 2**0
ALLOC
3 .stab 00002f4c 00000000 00000000 00001be8 2**2
CONTENTS, READONLY, DEBUGGING
4 .stabstr 0000132e 00000000 00000000 00004b34 2**0
CONTENTS, READONLY, DEBUGGING
5 .debug_aranges 00000020 00000000 00000000 00005e62 2**0
CONTENTS, READONLY, DEBUGGING
6 .debug_pubnames 00000299 00000000 00000000 00005e82 2**0
CONTENTS, READONLY, DEBUGGING
7 .debug_info 000003ff 00000000 00000000 0000611b 2**0
CONTENTS, READONLY, DEBUGGING
8 .debug_abbrev 0000013e 00000000 00000000 0000651a 2**0
CONTENTS, READONLY, DEBUGGING
9 .debug_line 00000f52 00000000 00000000 00006658 2**0
CONTENTS, READONLY, DEBUGGING
10 .debug_frame 000000a0 00000000 00000000 000075ac 2**2
CONTENTS, READONLY, DEBUGGING
11 .debug_str 000002dc 00000000 00000000 0000764c 2**0
CONTENTS, READONLY, DEBUGGING
12 .debug_loc 000000ab 00000000 00000000 00007928 2**0
CONTENTS, READONLY, DEBUGGING
Disassembly of section .text:
00000000 <__vectors>:
0: 0c 94 c9 00 jmp 0x192 ; 0x192 <__ctors_end>
4: 0c 94 ac 0b jmp 0x1758 ; 0x1758 <__vector_1>
8: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
c: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
10: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
14: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
18: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
1c: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
20: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
24: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
28: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
2c: 0c 94 23 01 jmp 0x246 ; 0x246 <__vector_11>
30: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
34: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
38: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
3c: 0c 94 ff 00 jmp 0x1fe ; 0x1fe <__vector_15>
40: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
44: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
48: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
4c: 0c 94 71 09 jmp 0x12e2 ; 0x12e2 <__vector_19>
50: 0c 94 89 0a jmp 0x1512 ; 0x1512 <__vector_20>
54: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
58: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
5c: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
60: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
64: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
68: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
6c: 0c 94 e6 00 jmp 0x1cc ; 0x1cc <__bad_interrupt>
70: c1 02 muls r28, r17
72: c7 02 muls r28, r23
74: ee 02 muls r30, r30
76: fc 02 muls r31, r28
78: 08 03 fmul r16, r16
7a: 10 03 mulsu r17, r16
7c: 21 03 mulsu r18, r17
7e: 29 03 fmul r18, r17
80: 3a 03 fmul r19, r18
82: 53 03 mulsu r21, r19
84: 6f 03 fmul r22, r23
86: 85 03 fmuls r16, r21
88: bd 03 fmulsu r19, r21
8a: 2a 04 cpc r2, r10
8c: 60 04 cpc r6, r0
8e: 6c 04 cpc r6, r12
90: 7c 04 cpc r7, r12
92: 86 04 cpc r8, r6
94: 98 04 cpc r9, r8
96: 73 05 cpc r23, r3
98: 80 05 cpc r24, r0
9a: b4 05 cpc r27, r4
0000009c <menuTable>:
9c: 20 20 20 20 20 43 4d 74 65 63 20 20 20 20 20 20 CMtec
ac: 72 6f 62 6f 43 72 61 77 6c 65 72 20 76 31 2e 31 roboCrawler v1.1
bc: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20
cc: 00 20 20 20 20 20 6d 6f 64 65 20 31 3a 20 20 20 . mode 1:
dc: 20 20 46 6f 6c 6c 6f 77 20 77 61 6c 6c 20 61 74 Follow wall at
ec: 20 20 61 20 64 69 73 74 61 6e 63 65 28 31 6d 29 a distance(1m)
fc: 20 00 20 20 20 20 20 6d 6f 64 65 20 32 3a 20 20 . mode 2:
10c: 20 20 20 44 72 69 76 65 20 61 6e 64 20 76 6f 69 Drive and voi
11c: 64 20 20 20 20 61 6e 79 20 77 61 6c 6c 73 20 20 d any walls
12c: 20 20 00 20 20 20 20 20 6d 6f 64 65 20 33 3a 20 . mode 3:
13c: 20 20 20 4d 65 61 73 75 72 65 20 64 69 73 74 61 Measure dista
14c: 6e 63 65 20 20 20 20 66 6f 72 77 61 72 64 20 20 nce forward
15c: 20 20 20 00 20 20 20 20 6d 6f 64 65 20 52 46 3a . mode RF:
16c: 20 20 20 20 20 52 46 20 61 63 74 69 76 65 64 20 RF actived
17c: 61 6e 64 20 77 61 69 74 69 6e 67 20 66 6f 72 20 and waiting for
18c: 63 6f 6d 2e 00 00 com...
00000192 <__ctors_end>:
192: 11 24 eor r1, r1
194: 1f be out 0x3f, r1 ; 63
196: cf ef ldi r28, 0xFF ; 255
198: d4 e0 ldi r29, 0x04 ; 4
19a: de bf out 0x3e, r29 ; 62
19c: cd bf out 0x3d, r28 ; 61
0000019e <__do_copy_data>:
19e: 14 e0 ldi r17, 0x04 ; 4
1a0: a0 e0 ldi r26, 0x00 ; 0
1a2: b1 e0 ldi r27, 0x01 ; 1
1a4: ea e4 ldi r30, 0x4A ; 74
1a6: f8 e1 ldi r31, 0x18 ; 24
1a8: 02 c0 rjmp .+4 ; 0x1ae <.do_copy_data_start>
000001aa <.do_copy_data_loop>:
1aa: 05 90 lpm r0, Z+
1ac: 0d 92 st X+, r0
000001ae <.do_copy_data_start>:
1ae: aa 32 cpi r26, 0x2A ; 42
1b0: b1 07 cpc r27, r17
1b2: d9 f7 brne .-10 ; 0x1aa <.do_copy_data_loop>
000001b4 <__do_clear_bss>:
1b4: 14 e0 ldi r17, 0x04 ; 4
1b6: aa e2 ldi r26, 0x2A ; 42
1b8: b4 e0 ldi r27, 0x04 ; 4
1ba: 01 c0 rjmp .+2 ; 0x1be <.do_clear_bss_start>
000001bc <.do_clear_bss_loop>:
1bc: 1d 92 st X+, r1
000001be <.do_clear_bss_start>:
1be: a5 36 cpi r26, 0x65 ; 101
1c0: b1 07 cpc r27, r17
1c2: e1 f7 brne .-8 ; 0x1bc <.do_clear_bss_loop>
1c4: 0e 94 18 07 call 0xe30 ; 0xe30 <main>
1c8: 0c 94 24 0c jmp 0x1848 ; 0x1848 <_exit>
000001cc <__bad_interrupt>:
1cc: 0c 94 00 00 jmp 0 ; 0x0 <__heap_end>
000001d0 <initIO>:
Description: Initialise I/O
Input: -
Output: -
------------------------------------------------------------------------------------------------*/
void initIO (void){
1d0: 82 e0 ldi r24, 0x02 ; 2
1d2: 8e bd out 0x2e, r24 ; 46
TCCR1B = (1<<CS11); // Timer1 prescaler = fc/8
TCNT1H = (uint8_t)(PROG_TIMER>>8);
1d4: 8f eb ldi r24, 0xBF ; 191
1d6: 8d bd out 0x2d, r24 ; 45
TCNT1L = (uint8_t)(PROG_TIMER);
1d8: 8f ef ldi r24, 0xFF ; 255
1da: 8c bd out 0x2c, r24 ; 44
TCNT2 = SERVO_TIMER;
1dc: 8e ee ldi r24, 0xEE ; 238
1de: 83 bd out 0x23, r24 ; 35
TIMSK |= (1<<TOIE1)|(1<<TOIE2); // Timer1 interrupt enable
1e0: 89 b7 in r24, 0x39 ; 57
1e2: 84 68 ori r24, 0x84 ; 132
1e4: 89 bf out 0x39, r24 ; 57
DDRC |= (1<<PC0)|(1<<PC1)|(1<<PC2);
1e6: 84 b3 in r24, 0x14 ; 20
1e8: 87 60 ori r24, 0x07 ; 7
1ea: 84 bb out 0x14, r24 ; 20
DDRA &= ~((1<<PA4)|(1<<PA5)|(1<<PA6)|(1<<PA7)); // Configuration button pins as input
1ec: 8a b3 in r24, 0x1a ; 26
1ee: 8f 70 andi r24, 0x0F ; 15
1f0: 8a bb out 0x1a, r24 ; 26
PORTA |= (1<<PA4)|(1<<PA5)|(1<<PA6)|(1<<PA7); // Pull-up on configuration button pins
1f2: 8b b3 in r24, 0x1b ; 27
1f4: 80 6f ori r24, 0xF0 ; 240
1f6: 8b bb out 0x1b, r24 ; 27
progPosition = 0;
1f8: 10 92 2f 04 sts 0x042F, r1
1fc: 08 95 ret
000001fe <__vector_15>:
Description: Timer1 overflow interrupt. Used as program timer
Input: -
Output: -
------------------------------------------------------------------------------------------------*/
ISR (TIMER1_OVF_vect)
{
1fe: 1f 92 push r1
200: 0f 92 push r0
202: 0f b6 in r0, 0x3f ; 63
204: 0f 92 push r0
206: 11 24 eor r1, r1
208: 8f 93 push r24
// Program for update PPM pulses to all servos
if (++progCounterPPM >= 2)
20a: 80 91 2c 04 lds r24, 0x042C
20e: 8f 5f subi r24, 0xFF ; 255
210: 80 93 2c 04 sts 0x042C, r24
214: 82 30 cpi r24, 0x02 ; 2
216: 50 f0 brcs .+20 ; 0x22c <__vector_15+0x2e>
{
// Start for servo PPM pulses
servoCounter = 0;
218: 10 92 2a 04 sts 0x042A, r1
SERVO_PORT |= (1<<SERVO_PING)|(1<<SERVO_MOTOR_LEFT)|(1<<SERVO_MOTOR_RIGHT);
21c: 85 b3 in r24, 0x15 ; 21
21e: 87 60 ori r24, 0x07 ; 7
220: 85 bb out 0x15, r24 ; 21
TCCR2 |= (1<<CS21); // Timer2 start (prescaler = fc/8)
222: 87 b5 in r24, 0x27 ; 39
224: 82 60 ori r24, 0x02 ; 2
226: 87 bd out 0x27, r24 ; 39
progCounterPPM = 0;
228: 10 92 2c 04 sts 0x042C, r1
}
// Trigg program routine
progDoUpdate = 1;
22c: 81 e0 ldi r24, 0x01 ; 1
22e: 80 93 30 04 sts 0x0430, r24
// Set timer value
TCNT1H = (uint8_t)(PROG_TIMER>>8);
232: 8f eb ldi r24, 0xBF ; 191
234: 8d bd out 0x2d, r24 ; 45
TCNT1L = (uint8_t)(PROG_TIMER);
236: 8f ef ldi r24, 0xFF ; 255
238: 8c bd out 0x2c, r24 ; 44
23a: 8f 91 pop r24
23c: 0f 90 pop r0
23e: 0f be out 0x3f, r0 ; 63
240: 0f 90 pop r0
242: 1f 90 pop r1
244: 18 95 reti
00000246 <__vector_11>:
Description: Timer1 overflow interrupt. Used as servo (PPM) timer
Input: -
Output: -
------------------------------------------------------------------------------------------------*/
ISR (TIMER2_OVF_vect)
{
246: 1f 92 push r1
248: 0f 92 push r0
24a: 0f b6 in r0, 0x3f ; 63
24c: 0f 92 push r0
24e: 11 24 eor r1, r1
250: 2f 93 push r18
252: 8f 93 push r24
254: 9f 93 push r25
uint8_t done = 1;
// Check each servo output if pulselength is reached
if(servoCounter >= servoPing)
256: 90 91 2a 04 lds r25, 0x042A
25a: 80 91 03 04 lds r24, 0x0403
25e: 98 17 cp r25, r24
260: 18 f0 brcs .+6 ; 0x268 <__vector_11+0x22>
SERVO_PORT &= ~(1<<SERVO_PING);
262: a9 98 cbi 0x15, 1 ; 21
264: 21 e0 ldi r18, 0x01 ; 1
266: 02 c0 rjmp .+4 ; 0x26c <__vector_11+0x26>
else
{
done = 0;
asm volatile("NOP"); // Correction for constant interrupt length
268: 00 00 nop
26a: 20 e0 ldi r18, 0x00 ; 0
}
if(servoCounter >= servoMotorLeft)
26c: 80 91 04 04 lds r24, 0x0404
270: 98 17 cp r25, r24
272: 10 f0 brcs .+4 ; 0x278 <__vector_11+0x32>
SERVO_PORT &= ~(1<<SERVO_MOTOR_LEFT);
274: a8 98 cbi 0x15, 0 ; 21
276: 02 c0 rjmp .+4 ; 0x27c <__vector_11+0x36>
else
{
done = 0;
asm volatile("NOP"); // Correction for constant interrupt length
278: 00 00 nop
27a: 20 e0 ldi r18, 0x00 ; 0
}
if(servoCounter >= servoMotorRight)
27c: 80 91 05 04 lds r24, 0x0405
280: 98 17 cp r25, r24
282: 20 f0 brcs .+8 ; 0x28c <__vector_11+0x46>
SERVO_PORT &= ~(1<<SERVO_MOTOR_RIGHT);
284: aa 98 cbi 0x15, 2 ; 21
{
done = 0;
asm volatile("NOP"); // Correction for constant interrupt length
}
if(done)
286: 22 23 and r18, r18
288: 19 f4 brne .+6 ; 0x290 <__vector_11+0x4a>
28a: 06 c0 rjmp .+12 ; 0x298 <__vector_11+0x52>
if(servoCounter >= servoMotorRight)
SERVO_PORT &= ~(1<<SERVO_MOTOR_RIGHT);
else
{
done = 0;
asm volatile("NOP"); // Correction for constant interrupt length
28c: 00 00 nop
28e: 04 c0 rjmp .+8 ; 0x298 <__vector_11+0x52>
}
if(done)
TCCR2 &= ~(1<<CS21); // Timer1 stop
290: 87 b5 in r24, 0x27 ; 39
292: 8d 7f andi r24, 0xFD ; 253
294: 87 bd out 0x27, r24 ; 39
296: 05 c0 rjmp .+10 ; 0x2a2 <__vector_11+0x5c>
else
{
servoCounter++;
298: 9f 5f subi r25, 0xFF ; 255
29a: 90 93 2a 04 sts 0x042A, r25
asm volatile("NOP"); // Correction for constant interrupt length
29e: 00 00 nop
asm volatile("NOP");
2a0: 00 00 nop
}
TCNT2 = SERVO_TIMER;
2a2: 8e ee ldi r24, 0xEE ; 238
2a4: 83 bd out 0x23, r24 ; 35
2a6: 9f 91 pop r25
2a8: 8f 91 pop r24
2aa: 2f 91 pop r18
2ac: 0f 90 pop r0
2ae: 0f be out 0x3f, r0 ; 63
2b0: 0f 90 pop r0
2b2: 1f 90 pop r1
2b4: 18 95 reti
000002b6 <activateRobot>:
Description:
Input: -
Output: -
------------------------------------------------------------------------------------------------*/
void activateRobot(uint8_t mode)
{
2b6: 1f 93 push r17
2b8: 18 2f mov r17, r24
lcdSetLayout(0);
2ba: 80 e0 ldi r24, 0x00 ; 0
2bc: 0e 94 a8 07 call 0xf50 ; 0xf50 <lcdSetLayout>
lcdWriteStringP(menuTable[mode]);
2c0: 81 e3 ldi r24, 0x31 ; 49
2c2: 18 9f mul r17, r24
2c4: c0 01 movw r24, r0
2c6: 11 24 eor r1, r1
2c8: 84 56 subi r24, 0x64 ; 100
2ca: 9f 4f sbci r25, 0xFF ; 255
2cc: 0e 94 2d 08 call 0x105a ; 0x105a <lcdWriteStringP>
progTimer = 200;
2d0: 88 ec ldi r24, 0xC8 ; 200
2d2: 80 93 2e 04 sts 0x042E, r24
roboActive = mode;
2d6: 10 93 3b 04 sts 0x043B, r17
2da: 1f 91 pop r17
2dc: 08 95 ret
000002de <deactivateRobot>:
Description:
Input: -
Output: -
------------------------------------------------------------------------------------------------*/
void deactivateRobot(void)
{
2de: 10 92 3b 04 sts 0x043B, r1
roboActive = 0;
servoMotorLeft = SERVO_POS_MOTOR_STOP;
2e2: 87 e7 ldi r24, 0x77 ; 119
2e4: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_STOP;
2e8: 80 93 05 04 sts 0x0405, r24
servoPing = SERVO_POS_CENTER;
2ec: 8c e8 ldi r24, 0x8C ; 140
2ee: 80 93 03 04 sts 0x0403, r24
rfIdDisable();
2f2: 0e 94 bb 09 call 0x1376 ; 0x1376 <rfIdDisable>
2f6: 08 95 ret
000002f8 <showDistanceOnLCD>:
Description:
Input: -
Output: -
------------------------------------------------------------------------------------------------*/
void showDistanceOnLCD(uint16_t distance, uint8_t mode, uint8_t position)
{
2f8: 1f 93 push r17
2fa: cf 93 push r28
2fc: df 93 push r29
2fe: ec 01 movw r28, r24
300: 16 2f mov r17, r22
if(position == 1)
302: 41 30 cpi r20, 0x01 ; 1
304: 11 f4 brne .+4 ; 0x30a <showDistanceOnLCD+0x12>
lcdSetPos(0x00);
306: 80 e0 ldi r24, 0x00 ; 0
308: 07 c0 rjmp .+14 ; 0x318 <showDistanceOnLCD+0x20>
else if(position == 2)
30a: 42 30 cpi r20, 0x02 ; 2
30c: 11 f4 brne .+4 ; 0x312 <showDistanceOnLCD+0x1a>
lcdSetPos(0x10);
30e: 80 e1 ldi r24, 0x10 ; 16
310: 03 c0 rjmp .+6 ; 0x318 <showDistanceOnLCD+0x20>
else if(position == 3)
312: 43 30 cpi r20, 0x03 ; 3
314: 19 f4 brne .+6 ; 0x31c <showDistanceOnLCD+0x24>
lcdSetPos(0x20);
316: 80 e2 ldi r24, 0x20 ; 32
318: 0e 94 d3 07 call 0xfa6 ; 0xfa6 <lcdSetPos>
if(mode == 0) // Both arrow pointing in
31c: 11 23 and r17, r17
31e: b9 f5 brne .+110 ; 0x38e <showDistanceOnLCD+0x96>
{
if(distance > 32000)
320: 8d e7 ldi r24, 0x7D ; 125
322: c1 30 cpi r28, 0x01 ; 1
324: d8 07 cpc r29, r24
326: c8 f5 brcc .+114 ; 0x39a <showDistanceOnLCD+0xa2>
{
lcdWriteString(" ");
}
else if(distance > 16000)
328: 8e e3 ldi r24, 0x3E ; 62
32a: c1 38 cpi r28, 0x81 ; 129
32c: d8 07 cpc r29, r24
32e: 18 f0 brcs .+6 ; 0x336 <showDistanceOnLCD+0x3e>
{
lcdWriteString("> <");
330: 81 e1 ldi r24, 0x11 ; 17
332: 91 e0 ldi r25, 0x01 ; 1
334: ca c0 rjmp .+404 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 8000)
336: 8f e1 ldi r24, 0x1F ; 31
338: c1 34 cpi r28, 0x41 ; 65
33a: d8 07 cpc r29, r24
33c: 18 f0 brcs .+6 ; 0x344 <showDistanceOnLCD+0x4c>
{
lcdWriteString(">> <<");
33e: 82 e2 ldi r24, 0x22 ; 34
340: 91 e0 ldi r25, 0x01 ; 1
342: c3 c0 rjmp .+390 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 4000)
344: 8f e0 ldi r24, 0x0F ; 15
346: c1 3a cpi r28, 0xA1 ; 161
348: d8 07 cpc r29, r24
34a: 18 f0 brcs .+6 ; 0x352 <showDistanceOnLCD+0x5a>
{
lcdWriteString(">>> <<<");
34c: 83 e3 ldi r24, 0x33 ; 51
34e: 91 e0 ldi r25, 0x01 ; 1
350: bc c0 rjmp .+376 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 2000)
352: 87 e0 ldi r24, 0x07 ; 7
354: c1 3d cpi r28, 0xD1 ; 209
356: d8 07 cpc r29, r24
358: 18 f0 brcs .+6 ; 0x360 <showDistanceOnLCD+0x68>
{
lcdWriteString(">>>> <<<<");
35a: 84 e4 ldi r24, 0x44 ; 68
35c: 91 e0 ldi r25, 0x01 ; 1
35e: b5 c0 rjmp .+362 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 1000)
360: 83 e0 ldi r24, 0x03 ; 3
362: c9 3e cpi r28, 0xE9 ; 233
364: d8 07 cpc r29, r24
366: 18 f0 brcs .+6 ; 0x36e <showDistanceOnLCD+0x76>
{
lcdWriteString(">>>>> <<<<<");
368: 85 e5 ldi r24, 0x55 ; 85
36a: 91 e0 ldi r25, 0x01 ; 1
36c: ae c0 rjmp .+348 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 500)
36e: 81 e0 ldi r24, 0x01 ; 1
370: c5 3f cpi r28, 0xF5 ; 245
372: d8 07 cpc r29, r24
374: 18 f0 brcs .+6 ; 0x37c <showDistanceOnLCD+0x84>
{
lcdWriteString(">>>>>> <<<<<<");
376: 86 e6 ldi r24, 0x66 ; 102
378: 91 e0 ldi r25, 0x01 ; 1
37a: a7 c0 rjmp .+334 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 100)
37c: c5 36 cpi r28, 0x65 ; 101
37e: d1 05 cpc r29, r1
380: 18 f0 brcs .+6 ; 0x388 <showDistanceOnLCD+0x90>
{
lcdWriteString(">>>>>>> <<<<<<<");
382: 87 e7 ldi r24, 0x77 ; 119
384: 91 e0 ldi r25, 0x01 ; 1
386: a1 c0 rjmp .+322 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else
{
lcdWriteString(">>>>>>>[]<<<<<<<");
388: 88 e8 ldi r24, 0x88 ; 136
38a: 91 e0 ldi r25, 0x01 ; 1
38c: 9e c0 rjmp .+316 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
}
else if(mode == 1) // Both arrow pointing Out
38e: 11 30 cpi r17, 0x01 ; 1
390: d1 f5 brne .+116 ; 0x406 <showDistanceOnLCD+0x10e>
{
if(distance > 32000)
392: 8d e7 ldi r24, 0x7D ; 125
394: c1 30 cpi r28, 0x01 ; 1
396: d8 07 cpc r29, r24
398: 18 f0 brcs .+6 ; 0x3a0 <showDistanceOnLCD+0xa8>
{
lcdWriteString(" ");
39a: 80 e0 ldi r24, 0x00 ; 0
39c: 91 e0 ldi r25, 0x01 ; 1
39e: 95 c0 rjmp .+298 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 16000)
3a0: 8e e3 ldi r24, 0x3E ; 62
3a2: c1 38 cpi r28, 0x81 ; 129
3a4: d8 07 cpc r29, r24
3a6: 18 f0 brcs .+6 ; 0x3ae <showDistanceOnLCD+0xb6>
{
lcdWriteString(" < > ");
3a8: 89 e9 ldi r24, 0x99 ; 153
3aa: 91 e0 ldi r25, 0x01 ; 1
3ac: 8e c0 rjmp .+284 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 8000)
3ae: 8f e1 ldi r24, 0x1F ; 31
3b0: c1 34 cpi r28, 0x41 ; 65
3b2: d8 07 cpc r29, r24
3b4: 18 f0 brcs .+6 ; 0x3bc <showDistanceOnLCD+0xc4>
{
lcdWriteString(" << >> ");
3b6: 8a ea ldi r24, 0xAA ; 170
3b8: 91 e0 ldi r25, 0x01 ; 1
3ba: 87 c0 rjmp .+270 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 4000)
3bc: 8f e0 ldi r24, 0x0F ; 15
3be: c1 3a cpi r28, 0xA1 ; 161
3c0: d8 07 cpc r29, r24
3c2: 18 f0 brcs .+6 ; 0x3ca <showDistanceOnLCD+0xd2>
{
lcdWriteString(" <<< >>> ");
3c4: 8b eb ldi r24, 0xBB ; 187
3c6: 91 e0 ldi r25, 0x01 ; 1
3c8: 80 c0 rjmp .+256 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 2000)
3ca: 87 e0 ldi r24, 0x07 ; 7
3cc: c1 3d cpi r28, 0xD1 ; 209
3ce: d8 07 cpc r29, r24
3d0: 18 f0 brcs .+6 ; 0x3d8 <showDistanceOnLCD+0xe0>
{
lcdWriteString(" <<<< >>>> ");
3d2: 8c ec ldi r24, 0xCC ; 204
3d4: 91 e0 ldi r25, 0x01 ; 1
3d6: 79 c0 rjmp .+242 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 1000)
3d8: 83 e0 ldi r24, 0x03 ; 3
3da: c9 3e cpi r28, 0xE9 ; 233
3dc: d8 07 cpc r29, r24
3de: 18 f0 brcs .+6 ; 0x3e6 <showDistanceOnLCD+0xee>
{
lcdWriteString(" <<<<< >>>>> ");
3e0: 8d ed ldi r24, 0xDD ; 221
3e2: 91 e0 ldi r25, 0x01 ; 1
3e4: 72 c0 rjmp .+228 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 500)
3e6: 81 e0 ldi r24, 0x01 ; 1
3e8: c5 3f cpi r28, 0xF5 ; 245
3ea: d8 07 cpc r29, r24
3ec: 18 f0 brcs .+6 ; 0x3f4 <showDistanceOnLCD+0xfc>
{
lcdWriteString(" <<<<<< >>>>>> ");
3ee: 8e ee ldi r24, 0xEE ; 238
3f0: 91 e0 ldi r25, 0x01 ; 1
3f2: 6b c0 rjmp .+214 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 100)
3f4: c5 36 cpi r28, 0x65 ; 101
3f6: d1 05 cpc r29, r1
3f8: 18 f0 brcs .+6 ; 0x400 <showDistanceOnLCD+0x108>
{
lcdWriteString("<<<<<<< >>>>>>>");
3fa: 8f ef ldi r24, 0xFF ; 255
3fc: 91 e0 ldi r25, 0x01 ; 1
3fe: 65 c0 rjmp .+202 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else
{
lcdWriteString("<<<<<<<[]>>>>>>>");
400: 80 e1 ldi r24, 0x10 ; 16
402: 92 e0 ldi r25, 0x02 ; 2
404: 62 c0 rjmp .+196 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
}
else if(mode == 2) // Left arrow pointing out.
406: 12 30 cpi r17, 0x02 ; 2
408: 71 f5 brne .+92 ; 0x466 <showDistanceOnLCD+0x16e>
{
if(distance > 6400)
40a: 89 e1 ldi r24, 0x19 ; 25
40c: c1 30 cpi r28, 0x01 ; 1
40e: d8 07 cpc r29, r24
410: 18 f0 brcs .+6 ; 0x418 <showDistanceOnLCD+0x120>
{
lcdWriteString("<<<<<<< ");
412: 81 e2 ldi r24, 0x21 ; 33
414: 92 e0 ldi r25, 0x02 ; 2
416: 59 c0 rjmp .+178 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 3200)
418: 8c e0 ldi r24, 0x0C ; 12
41a: c1 38 cpi r28, 0x81 ; 129
41c: d8 07 cpc r29, r24
41e: 18 f0 brcs .+6 ; 0x426 <showDistanceOnLCD+0x12e>
{
lcdWriteString(" <<<<<< ");
420: 82 e3 ldi r24, 0x32 ; 50
422: 92 e0 ldi r25, 0x02 ; 2
424: 52 c0 rjmp .+164 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 1600)
426: 86 e0 ldi r24, 0x06 ; 6
428: c1 34 cpi r28, 0x41 ; 65
42a: d8 07 cpc r29, r24
42c: 18 f0 brcs .+6 ; 0x434 <showDistanceOnLCD+0x13c>
{
lcdWriteString(" <<<<< ");
42e: 83 e4 ldi r24, 0x43 ; 67
430: 92 e0 ldi r25, 0x02 ; 2
432: 4b c0 rjmp .+150 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 800)
434: 83 e0 ldi r24, 0x03 ; 3
436: c1 32 cpi r28, 0x21 ; 33
438: d8 07 cpc r29, r24
43a: 18 f0 brcs .+6 ; 0x442 <showDistanceOnLCD+0x14a>
{
lcdWriteString(" <<<< ");
43c: 84 e5 ldi r24, 0x54 ; 84
43e: 92 e0 ldi r25, 0x02 ; 2
440: 44 c0 rjmp .+136 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 400)
442: 81 e0 ldi r24, 0x01 ; 1
444: c1 39 cpi r28, 0x91 ; 145
446: d8 07 cpc r29, r24
448: 18 f0 brcs .+6 ; 0x450 <showDistanceOnLCD+0x158>
{
lcdWriteString(" <<< ");
44a: 85 e6 ldi r24, 0x65 ; 101
44c: 92 e0 ldi r25, 0x02 ; 2
44e: 3d c0 rjmp .+122 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 200)
450: c9 3c cpi r28, 0xC9 ; 201
452: d1 05 cpc r29, r1
454: 18 f0 brcs .+6 ; 0x45c <showDistanceOnLCD+0x164>
{
lcdWriteString(" << ");
456: 86 e7 ldi r24, 0x76 ; 118
458: 92 e0 ldi r25, 0x02 ; 2
45a: 37 c0 rjmp .+110 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 30)
45c: 6f 97 sbiw r28, 0x1f ; 31
45e: 98 f1 brcs .+102 ; 0x4c6 <showDistanceOnLCD+0x1ce>
{
lcdWriteString(" < ");
460: 87 e8 ldi r24, 0x87 ; 135
462: 92 e0 ldi r25, 0x02 ; 2
464: 32 c0 rjmp .+100 ; 0x4ca <showDistanceOnLCD+0x1d2>
else
{
lcdWriteString(" [] ");
}
}
else if(mode == 3) // Right arrow pointing out.
466: 13 30 cpi r17, 0x03 ; 3
468: 91 f5 brne .+100 ; 0x4ce <showDistanceOnLCD+0x1d6>
{
if(distance > 6400)
46a: 89 e1 ldi r24, 0x19 ; 25
46c: c1 30 cpi r28, 0x01 ; 1
46e: d8 07 cpc r29, r24
470: 18 f0 brcs .+6 ; 0x478 <showDistanceOnLCD+0x180>
{
lcdWriteString(" >>>>>>>");
472: 89 ea ldi r24, 0xA9 ; 169
474: 92 e0 ldi r25, 0x02 ; 2
476: 29 c0 rjmp .+82 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 3200)
478: 8c e0 ldi r24, 0x0C ; 12
47a: c1 38 cpi r28, 0x81 ; 129
47c: d8 07 cpc r29, r24
47e: 18 f0 brcs .+6 ; 0x486 <showDistanceOnLCD+0x18e>
{
lcdWriteString(" >>>>>> ");
480: 8a eb ldi r24, 0xBA ; 186
482: 92 e0 ldi r25, 0x02 ; 2
484: 22 c0 rjmp .+68 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 1600)
486: 86 e0 ldi r24, 0x06 ; 6
488: c1 34 cpi r28, 0x41 ; 65
48a: d8 07 cpc r29, r24
48c: 18 f0 brcs .+6 ; 0x494 <showDistanceOnLCD+0x19c>
{
lcdWriteString(" >>>>> ");
48e: 8b ec ldi r24, 0xCB ; 203
490: 92 e0 ldi r25, 0x02 ; 2
492: 1b c0 rjmp .+54 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 800)
494: 83 e0 ldi r24, 0x03 ; 3
496: c1 32 cpi r28, 0x21 ; 33
498: d8 07 cpc r29, r24
49a: 18 f0 brcs .+6 ; 0x4a2 <showDistanceOnLCD+0x1aa>
{
lcdWriteString(" >>>> ");
49c: 8c ed ldi r24, 0xDC ; 220
49e: 92 e0 ldi r25, 0x02 ; 2
4a0: 14 c0 rjmp .+40 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 400)
4a2: 81 e0 ldi r24, 0x01 ; 1
4a4: c1 39 cpi r28, 0x91 ; 145
4a6: d8 07 cpc r29, r24
4a8: 18 f0 brcs .+6 ; 0x4b0 <showDistanceOnLCD+0x1b8>
{
lcdWriteString(" >>> ");
4aa: 8d ee ldi r24, 0xED ; 237
4ac: 92 e0 ldi r25, 0x02 ; 2
4ae: 0d c0 rjmp .+26 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 200)
4b0: c9 3c cpi r28, 0xC9 ; 201
4b2: d1 05 cpc r29, r1
4b4: 18 f0 brcs .+6 ; 0x4bc <showDistanceOnLCD+0x1c4>
{
lcdWriteString(" >> ");
4b6: 8e ef ldi r24, 0xFE ; 254
4b8: 92 e0 ldi r25, 0x02 ; 2
4ba: 07 c0 rjmp .+14 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else if(distance > 30)
4bc: 6f 97 sbiw r28, 0x1f ; 31
4be: 18 f0 brcs .+6 ; 0x4c6 <showDistanceOnLCD+0x1ce>
{
lcdWriteString(" > ");
4c0: 8f e0 ldi r24, 0x0F ; 15
4c2: 93 e0 ldi r25, 0x03 ; 3
4c4: 02 c0 rjmp .+4 ; 0x4ca <showDistanceOnLCD+0x1d2>
}
else
{
lcdWriteString(" [] ");
4c6: 88 e9 ldi r24, 0x98 ; 152
4c8: 92 e0 ldi r25, 0x02 ; 2
4ca: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
4ce: df 91 pop r29
4d0: cf 91 pop r28
4d2: 1f 91 pop r17
4d4: 08 95 ret
000004d6 <checkCommunication>:
Description: Check for incoming data packets.
Input: -
Output: -
------------------------------------------------------------------------------------------------*/
void checkCommunication(void){
4d6: 0f 93 push r16
4d8: 1f 93 push r17
if (rfIdGetTagPresent())
4da: 0e 94 6d 09 call 0x12da ; 0x12da <rfIdGetTagPresent>
4de: 88 23 and r24, r24
4e0: 61 f0 breq .+24 ; 0x4fa <checkCommunication+0x24>
{
uint8_t *tempPointer = rfIdGetTag();
4e2: 0e 94 64 09 call 0x12c8 ; 0x12c8 <rfIdGetTag>
4e6: 8c 01 movw r16, r24
lcdSetPos(0x13);
4e8: 83 e1 ldi r24, 0x13 ; 19
4ea: 0e 94 d3 07 call 0xfa6 ; 0xfa6 <lcdSetPos>
lcdWriteString(tempPointer);
4ee: c8 01 movw r24, r16
4f0: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
roboMSPSetData(tempPointer);
4f4: c8 01 movw r24, r16
4f6: 0e 94 13 0a call 0x1426 ; 0x1426 <roboMSPSetData>
}
switch (roboMSPGetActiveStatus())
4fa: 0e 94 c3 09 call 0x1386 ; 0x1386 <roboMSPGetActiveStatus>
4fe: 83 30 cpi r24, 0x03 ; 3
500: 61 f0 breq .+24 ; 0x51a <__stack+0x1b>
502: 84 30 cpi r24, 0x04 ; 4
504: 18 f4 brcc .+6 ; 0x50c <__stack+0xd>
506: 82 30 cpi r24, 0x02 ; 2
508: 99 f4 brne .+38 ; 0x530 <__stack+0x31>
50a: 05 c0 rjmp .+10 ; 0x516 <__stack+0x17>
50c: 84 30 cpi r24, 0x04 ; 4
50e: 59 f0 breq .+22 ; 0x526 <__stack+0x27>
510: 85 30 cpi r24, 0x05 ; 5
512: 71 f4 brne .+28 ; 0x530 <__stack+0x31>
514: 0b c0 rjmp .+22 ; 0x52c <__stack+0x2d>
{
case ACTIVATE_P1:
activateRobot(1);
516: 81 e0 ldi r24, 0x01 ; 1
518: 01 c0 rjmp .+2 ; 0x51c <__stack+0x1d>
rfIdEnable();
break;
case ACTIVATE_P2:
activateRobot(2);
51a: 82 e0 ldi r24, 0x02 ; 2
51c: 0e 94 5b 01 call 0x2b6 ; 0x2b6 <activateRobot>
rfIdEnable();
520: 0e 94 bf 09 call 0x137e ; 0x137e <rfIdEnable>
524: 05 c0 rjmp .+10 ; 0x530 <__stack+0x31>
break;
case DEACTIVATE:
deactivateRobot();
526: 0e 94 6f 01 call 0x2de ; 0x2de <deactivateRobot>
52a: 02 c0 rjmp .+4 ; 0x530 <__stack+0x31>
break;
case ACK:
rfIdClearBuffer();
52c: 0e 94 69 09 call 0x12d2 ; 0x12d2 <rfIdClearBuffer>
530: 1f 91 pop r17
532: 0f 91 pop r16
534: 08 95 ret
00000536 <updateProgram>:
Description:
Input: -
Output: -
------------------------------------------------------------------------------------------------*/
void updateProgram(void)
{
536: 1f 93 push r17
// Check radio communication
if(rfEnable)
538: 80 91 3c 04 lds r24, 0x043C
53c: 88 23 and r24, r24
53e: 11 f0 breq .+4 ; 0x544 <updateProgram+0xe>
checkCommunication();
540: 0e 94 6b 02 call 0x4d6 ; 0x4d6 <checkCommunication>
// Program for robot AI
if (roboActive == 1)
544: 80 91 3b 04 lds r24, 0x043B
548: 81 30 cpi r24, 0x01 ; 1
54a: 09 f0 breq .+2 ; 0x54e <updateProgram+0x18>
54c: 1e c3 rjmp .+1596 ; 0xb8a <updateProgram+0x654>
{
// Program(2) for random RFID serach
if (++progCounter >= progTimer)
54e: 80 91 2d 04 lds r24, 0x042D
552: 8f 5f subi r24, 0xFF ; 255
554: 80 93 2d 04 sts 0x042D, r24
558: 90 91 2e 04 lds r25, 0x042E
55c: 89 17 cp r24, r25
55e: 08 f4 brcc .+2 ; 0x562 <updateProgram+0x2c>
560: 14 c3 rjmp .+1576 ; 0xb8a <updateProgram+0x654>
{
switch (progPosition)
562: 80 91 2f 04 lds r24, 0x042F
566: e8 2f mov r30, r24
568: f0 e0 ldi r31, 0x00 ; 0
56a: e6 31 cpi r30, 0x16 ; 22
56c: f1 05 cpc r31, r1
56e: 08 f0 brcs .+2 ; 0x572 <updateProgram+0x3c>
570: 0a c3 rjmp .+1556 ; 0xb86 <updateProgram+0x650>
572: e8 5c subi r30, 0xC8 ; 200
574: ff 4f sbci r31, 0xFF ; 255
576: ee 0f add r30, r30
578: ff 1f adc r31, r31
57a: 05 90 lpm r0, Z+
57c: f4 91 lpm r31, Z
57e: e0 2d mov r30, r0
580: 09 94 ijmp
{
case 0:
// K<>r framm<6D>t
lcdClearDisplay();
582: 0e 94 df 07 call 0xfbe ; 0xfbe <lcdClearDisplay>
lcdSetLayout(1);
586: 81 e0 ldi r24, 0x01 ; 1
588: 0e 94 a8 07 call 0xf50 ; 0xf50 <lcdSetLayout>
58c: a5 c1 rjmp .+842 ; 0x8d8 <updateProgram+0x3a2>
break;
case 1:
// K<>r framm<6D>t till dess att avst<73>ndet mot v<>ggen <20>r 1meter
servoMotorLeft = SERVO_POS_MOTOR_FW_SOFT;
58e: 8f e7 ldi r24, 0x7F ; 127
590: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_FW_SOFT;
594: 80 93 05 04 sts 0x0405, r24
pingSendPing();
598: 0e 94 8c 0b call 0x1718 ; 0x1718 <pingSendPing>
progTimer = 4;
59c: 84 e0 ldi r24, 0x04 ; 4
59e: 80 93 2e 04 sts 0x042E, r24
if(pingGetReady())
5a2: 0e 94 a7 0b call 0x174e ; 0x174e <pingGetReady>
5a6: 88 23 and r24, r24
5a8: 09 f4 brne .+2 ; 0x5ac <updateProgram+0x76>
5aa: ed c2 rjmp .+1498 ; 0xb86 <updateProgram+0x650>
{
tempDistance = pingGetDistance();
5ac: 0e 94 a0 0b call 0x1740 ; 0x1740 <pingGetDistance>
5b0: 90 93 32 04 sts 0x0432, r25
5b4: 80 93 31 04 sts 0x0431, r24
if(tempDistance < DISTANCE_ONE_METER)
5b8: 27 e1 ldi r18, 0x17 ; 23
5ba: 80 37 cpi r24, 0x70 ; 112
5bc: 92 07 cpc r25, r18
5be: 38 f4 brcc .+14 ; 0x5ce <updateProgram+0x98>
{
showDistanceOnLCD(0,0,2);
5c0: 42 e0 ldi r20, 0x02 ; 2
5c2: 60 e0 ldi r22, 0x00 ; 0
5c4: 80 e0 ldi r24, 0x00 ; 0
5c6: 90 e0 ldi r25, 0x00 ; 0
5c8: 0e 94 7c 01 call 0x2f8 ; 0x2f8 <showDistanceOnLCD>
5cc: af c1 rjmp .+862 ; 0x92c <updateProgram+0x3f6>
progTimer = 1;
progPosition++;
}
else
{
showDistanceOnLCD(tempDistance-DISTANCE_ONE_METER,0,2);
5ce: 42 e0 ldi r20, 0x02 ; 2
5d0: 60 e0 ldi r22, 0x00 ; 0
5d2: 80 57 subi r24, 0x70 ; 112
5d4: 97 41 sbci r25, 0x17 ; 23
5d6: 0e 94 7c 01 call 0x2f8 ; 0x2f8 <showDistanceOnLCD>
5da: d5 c2 rjmp .+1450 ; 0xb86 <updateProgram+0x650>
break;
case 2:
// Bromsa (backa n<>got)
lcdSetPos(0x00);
5dc: 80 e0 ldi r24, 0x00 ; 0
5de: 0e 94 d3 07 call 0xfa6 ; 0xfa6 <lcdSetPos>
lcdWriteString("Drive: STOP ");
5e2: 81 e3 ldi r24, 0x31 ; 49
5e4: 93 e0 ldi r25, 0x03 ; 3
5e6: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
// Stop and breake
servoMotorLeft = SERVO_POS_MOTOR_STOP;
servoMotorRight = SERVO_POS_MOTOR_STOP;
servoMotorLeft = SERVO_POS_MOTOR_RE;
5ea: 8c e6 ldi r24, 0x6C ; 108
5ec: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_RE;
5f0: 80 93 05 04 sts 0x0405, r24
progTimer = 40;
5f4: 88 e2 ldi r24, 0x28 ; 40
5f6: 7d c1 rjmp .+762 ; 0x8f2 <updateProgram+0x3bc>
break;
case 3:
// Stanna
servoMotorLeft = SERVO_POS_MOTOR_STOP;
5f8: 87 e7 ldi r24, 0x77 ; 119
5fa: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_STOP;
5fe: 80 93 05 04 sts 0x0405, r24
progTimer = 1;
602: 81 e0 ldi r24, 0x01 ; 1
604: 80 93 2e 04 sts 0x042E, r24
regulatorMeasureCounter = 0;
608: 10 92 42 04 sts 0x0442, r1
progPosition++;
60c: 84 e0 ldi r24, 0x04 ; 4
60e: b9 c2 rjmp .+1394 ; 0xb82 <updateProgram+0x64c>
break;
case 4:
// Vrid servo 45grader v<>nster (fr<66>n centrum)
servoPing = SERVO_POS_LEFT_45;
610: 8e ea ldi r24, 0xAE ; 174
612: 80 93 03 04 sts 0x0403, r24
progTimer = 20;
616: 84 e1 ldi r24, 0x14 ; 20
618: 80 93 2e 04 sts 0x042E, r24
progPosition++;
61c: 85 e0 ldi r24, 0x05 ; 5
61e: b1 c2 rjmp .+1378 ; 0xb82 <updateProgram+0x64c>
break;
case 5:
// M<>t och spara avst<73>nd
pingSendPing();
620: 0e 94 8c 0b call 0x1718 ; 0x1718 <pingSendPing>
progTimer = 4;
624: 84 e0 ldi r24, 0x04 ; 4
626: 80 93 2e 04 sts 0x042E, r24
if(pingGetReady())
62a: 0e 94 a7 0b call 0x174e ; 0x174e <pingGetReady>
62e: 88 23 and r24, r24
630: 09 f4 brne .+2 ; 0x634 <updateProgram+0xfe>
632: a9 c2 rjmp .+1362 ; 0xb86 <updateProgram+0x650>
{
tempLeftDistance = pingGetDistance();
634: 0e 94 a0 0b call 0x1740 ; 0x1740 <pingGetDistance>
638: 90 93 38 04 sts 0x0438, r25
63c: 80 93 37 04 sts 0x0437, r24
640: 75 c1 rjmp .+746 ; 0x92c <updateProgram+0x3f6>
break;
case 6:
// Vrid servo 45grader h<>ger (fr<66>n centrum)
servoPing = SERVO_POS_RIGHT_45;
642: 87 e6 ldi r24, 0x67 ; 103
644: 80 93 03 04 sts 0x0403, r24
progTimer = 40;
648: 88 e2 ldi r24, 0x28 ; 40
64a: 80 93 2e 04 sts 0x042E, r24
progPosition++;
64e: 87 e0 ldi r24, 0x07 ; 7
650: 98 c2 rjmp .+1328 ; 0xb82 <updateProgram+0x64c>
break;
case 7:
// M<>t och spara avst<73>nd
pingSendPing();
652: 0e 94 8c 0b call 0x1718 ; 0x1718 <pingSendPing>
progTimer = 4;
656: 84 e0 ldi r24, 0x04 ; 4
658: 80 93 2e 04 sts 0x042E, r24
if(pingGetReady())
65c: 0e 94 a7 0b call 0x174e ; 0x174e <pingGetReady>
660: 88 23 and r24, r24
662: 09 f4 brne .+2 ; 0x666 <updateProgram+0x130>
664: 90 c2 rjmp .+1312 ; 0xb86 <updateProgram+0x650>
{
tempRightDistance = pingGetDistance();
666: 0e 94 a0 0b call 0x1740 ; 0x1740 <pingGetDistance>
66a: 90 93 3a 04 sts 0x043A, r25
66e: 80 93 39 04 sts 0x0439, r24
672: 5c c1 rjmp .+696 ; 0x92c <updateProgram+0x3f6>
break;
case 8:
servoPing = SERVO_POS_CENTER;
674: 8c e8 ldi r24, 0x8C ; 140
676: 80 93 03 04 sts 0x0403, r24
if(tempLeftDistance > tempRightDistance)
67a: 20 91 37 04 lds r18, 0x0437
67e: 30 91 38 04 lds r19, 0x0438
682: 80 91 39 04 lds r24, 0x0439
686: 90 91 3a 04 lds r25, 0x043A
68a: 82 17 cp r24, r18
68c: 93 07 cpc r25, r19
68e: 18 f4 brcc .+6 ; 0x696 <updateProgram+0x160>
{
regulatorMode = 0; // M<>ter <20>t h<>ger
690: 10 92 3f 04 sts 0x043F, r1
694: 03 c0 rjmp .+6 ; 0x69c <updateProgram+0x166>
}
else
{
regulatorMode = 1; // M<>ter <20>t v<>nster
696: 81 e0 ldi r24, 0x01 ; 1
698: 80 93 3f 04 sts 0x043F, r24
}
progTimer = 50;
69c: 82 e3 ldi r24, 0x32 ; 50
69e: 80 93 2e 04 sts 0x042E, r24
progPosition++;
6a2: 89 e0 ldi r24, 0x09 ; 9
6a4: 6e c2 rjmp .+1244 ; 0xb82 <updateProgram+0x64c>
break;
case 9:
// M<>t och spara avst<73>nd
pingSendPing();
6a6: 0e 94 8c 0b call 0x1718 ; 0x1718 <pingSendPing>
progTimer = 4;
6aa: 84 e0 ldi r24, 0x04 ; 4
6ac: 80 93 2e 04 sts 0x042E, r24
if(pingGetReady())
6b0: 0e 94 a7 0b call 0x174e ; 0x174e <pingGetReady>
6b4: 88 23 and r24, r24
6b6: 09 f4 brne .+2 ; 0x6ba <updateProgram+0x184>
6b8: 66 c2 rjmp .+1228 ; 0xb86 <updateProgram+0x650>
{
lcdSetPos(0x00);
6ba: 80 e0 ldi r24, 0x00 ; 0
6bc: 0e 94 d3 07 call 0xfa6 ; 0xfa6 <lcdSetPos>
lcdWriteString("Align to wall ");
6c0: 82 e4 ldi r24, 0x42 ; 66
6c2: 93 e0 ldi r25, 0x03 ; 3
6c4: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
tempLastDistanceToWall = pingGetDistance();
6c8: 0e 94 a0 0b call 0x1740 ; 0x1740 <pingGetDistance>
6cc: 90 93 36 04 sts 0x0436, r25
6d0: 80 93 35 04 sts 0x0435, r24
tempDistanceToWall = tempLastDistanceToWall;
6d4: 90 93 34 04 sts 0x0434, r25
6d8: 80 93 33 04 sts 0x0433, r24
6dc: 27 c1 rjmp .+590 ; 0x92c <updateProgram+0x3f6>
break;
case 10:
// Reglera in sig vinker<65>t mot v<>ggen
// Vrider sig ett steg
if (regulatorMode == 0) // Tittar h<>ger
6de: 80 91 3f 04 lds r24, 0x043F
6e2: 88 23 and r24, r24
6e4: 29 f4 brne .+10 ; 0x6f0 <updateProgram+0x1ba>
{
// sv<73>ng h<>ger
servoMotorLeft = SERVO_POS_MOTOR_FW_FAST;
6e6: 86 e8 ldi r24, 0x86 ; 134
6e8: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_RE_FAST;
6ec: 88 e6 ldi r24, 0x68 ; 104
6ee: 06 c0 rjmp .+12 ; 0x6fc <updateProgram+0x1c6>
progTimer = 7;
}
else if (regulatorMode == 1) // Tittar v<>nster
6f0: 81 30 cpi r24, 0x01 ; 1
6f2: 49 f4 brne .+18 ; 0x706 <updateProgram+0x1d0>
{
// sv<73>ng v<>nster
servoMotorLeft = SERVO_POS_MOTOR_RE_FAST;
6f4: 88 e6 ldi r24, 0x68 ; 104
6f6: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_FW_FAST;
6fa: 86 e8 ldi r24, 0x86 ; 134
6fc: 80 93 05 04 sts 0x0405, r24
progTimer = 7;
700: 87 e0 ldi r24, 0x07 ; 7
702: 80 93 2e 04 sts 0x042E, r24
}
progPosition++;
706: 8b e0 ldi r24, 0x0B ; 11
708: 3c c2 rjmp .+1144 ; 0xb82 <updateProgram+0x64c>
break;
case 11:
// Reglera in sig vinker<65>t mot v<>ggen
// Kontrollerar avst<73>nd
pingSendPing();
70a: 0e 94 8c 0b call 0x1718 ; 0x1718 <pingSendPing>
progTimer = 4;
70e: 84 e0 ldi r24, 0x04 ; 4
710: 80 93 2e 04 sts 0x042E, r24
servoMotorLeft = SERVO_POS_MOTOR_STOP;
714: 87 e7 ldi r24, 0x77 ; 119
716: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_STOP;
71a: 80 93 05 04 sts 0x0405, r24
if(pingGetReady())
71e: 0e 94 a7 0b call 0x174e ; 0x174e <pingGetReady>
722: 88 23 and r24, r24
724: 09 f4 brne .+2 ; 0x728 <updateProgram+0x1f2>
726: 2f c2 rjmp .+1118 ; 0xb86 <updateProgram+0x650>
{
tempDistance = pingGetDistance();
728: 0e 94 a0 0b call 0x1740 ; 0x1740 <pingGetDistance>
72c: 90 93 32 04 sts 0x0432, r25
730: 80 93 31 04 sts 0x0431, r24
if(tempDistance > tempLastDistanceToWall)
734: 20 91 35 04 lds r18, 0x0435
738: 30 91 36 04 lds r19, 0x0436
73c: 28 17 cp r18, r24
73e: 39 07 cpc r19, r25
740: 70 f4 brcc .+28 ; 0x75e <updateProgram+0x228>
{
lcdSetPos(0x00);
742: 80 e0 ldi r24, 0x00 ; 0
744: 0e 94 d3 07 call 0xfa6 ; 0xfa6 <lcdSetPos>
lcdWriteString(" ^-- (1m) --^ ");
748: 83 e5 ldi r24, 0x53 ; 83
74a: 93 e0 ldi r25, 0x03 ; 3
74c: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
progTimer = 1;
750: 81 e0 ldi r24, 0x01 ; 1
752: 80 93 2e 04 sts 0x042E, r24
progPosition++;
756: 80 91 2f 04 lds r24, 0x042F
75a: 8f 5f subi r24, 0xFF ; 255
75c: 03 c0 rjmp .+6 ; 0x764 <updateProgram+0x22e>
}
else
progPosition--;
75e: 80 91 2f 04 lds r24, 0x042F
762: 81 50 subi r24, 0x01 ; 1
764: 80 93 2f 04 sts 0x042F, r24
tempLastDistanceToWall = tempDistance;
768: 80 91 31 04 lds r24, 0x0431
76c: 90 91 32 04 lds r25, 0x0432
770: 90 93 36 04 sts 0x0436, r25
774: 80 93 35 04 sts 0x0435, r24
778: 06 c2 rjmp .+1036 ; 0xb86 <updateProgram+0x650>
break;
case 12:
// Reglera in position 1meter fr<66>n v<>ggen
pingSendPing();
77a: 0e 94 8c 0b call 0x1718 ; 0x1718 <pingSendPing>
progTimer = 4;
77e: 84 e0 ldi r24, 0x04 ; 4
780: 80 93 2e 04 sts 0x042E, r24
if(pingGetReady())
784: 0e 94 a7 0b call 0x174e ; 0x174e <pingGetReady>
788: 88 23 and r24, r24
78a: 09 f4 brne .+2 ; 0x78e <updateProgram+0x258>
78c: fc c1 rjmp .+1016 ; 0xb86 <updateProgram+0x650>
{
tempDistance = pingGetDistance();
78e: 0e 94 a0 0b call 0x1740 ; 0x1740 <pingGetDistance>
792: 9c 01 movw r18, r24
794: 90 93 32 04 sts 0x0432, r25
798: 80 93 31 04 sts 0x0431, r24
if(tempDistance > DISTANCE_ONE_METER)
79c: 47 e1 ldi r20, 0x17 ; 23
79e: 81 37 cpi r24, 0x71 ; 113
7a0: 94 07 cpc r25, r20
7a2: 28 f0 brcs .+10 ; 0x7ae <updateProgram+0x278>
showDistanceOnLCD((tempDistance-DISTANCE_ONE_METER),0,2);
7a4: 42 e0 ldi r20, 0x02 ; 2
7a6: 60 e0 ldi r22, 0x00 ; 0
7a8: 80 57 subi r24, 0x70 ; 112
7aa: 97 41 sbci r25, 0x17 ; 23
7ac: 06 c0 rjmp .+12 ; 0x7ba <updateProgram+0x284>
else
showDistanceOnLCD((DISTANCE_ONE_METER-tempDistance),1,2);
7ae: 42 e0 ldi r20, 0x02 ; 2
7b0: 61 e0 ldi r22, 0x01 ; 1
7b2: 80 e7 ldi r24, 0x70 ; 112
7b4: 97 e1 ldi r25, 0x17 ; 23
7b6: 82 1b sub r24, r18
7b8: 93 0b sbc r25, r19
7ba: 0e 94 7c 01 call 0x2f8 ; 0x2f8 <showDistanceOnLCD>
if(tempDistance < (DISTANCE_ONE_METER - 200))
7be: 80 91 31 04 lds r24, 0x0431
7c2: 90 91 32 04 lds r25, 0x0432
7c6: 26 e1 ldi r18, 0x16 ; 22
7c8: 88 3a cpi r24, 0xA8 ; 168
7ca: 92 07 cpc r25, r18
7cc: 58 f4 brcc .+22 ; 0x7e4 <updateProgram+0x2ae>
{
// K<>r framm<6D>t (<28>ka hastigheten l<>ngsamt)
if(servoMotorLeft > SERVO_POS_MOTOR_RE_SOFT)
7ce: 80 91 04 04 lds r24, 0x0404
7d2: 83 37 cpi r24, 0x73 ; 115
7d4: b0 f0 brcs .+44 ; 0x802 <updateProgram+0x2cc>
{
servoMotorLeft--;
7d6: 81 50 subi r24, 0x01 ; 1
7d8: 80 93 04 04 sts 0x0404, r24
servoMotorRight--;
7dc: 80 91 05 04 lds r24, 0x0405
7e0: 81 50 subi r24, 0x01 ; 1
7e2: 0d c0 rjmp .+26 ; 0x7fe <updateProgram+0x2c8>
}
regulatorMeasureCounter = 0;
}
else if(tempDistance > (DISTANCE_ONE_METER + 200))
7e4: 89 53 subi r24, 0x39 ; 57
7e6: 98 41 sbci r25, 0x18 ; 24
7e8: 78 f0 brcs .+30 ; 0x808 <updateProgram+0x2d2>
{
// K<>r bak<61>t (<28>ka hastigheten l<>ngsamt)
if(servoMotorLeft < SERVO_POS_MOTOR_FW_SOFT)
7ea: 80 91 04 04 lds r24, 0x0404
7ee: 8f 37 cpi r24, 0x7F ; 127
7f0: 40 f4 brcc .+16 ; 0x802 <updateProgram+0x2cc>
{
servoMotorLeft++;
7f2: 8f 5f subi r24, 0xFF ; 255
7f4: 80 93 04 04 sts 0x0404, r24
servoMotorRight++;
7f8: 80 91 05 04 lds r24, 0x0405
7fc: 8f 5f subi r24, 0xFF ; 255
7fe: 80 93 05 04 sts 0x0405, r24
}
regulatorMeasureCounter = 0;
802: 10 92 42 04 sts 0x0442, r1
806: bf c1 rjmp .+894 ; 0xb86 <updateProgram+0x650>
}
else
{
servoMotorLeft = SERVO_POS_MOTOR_STOP;
808: 17 e7 ldi r17, 0x77 ; 119
80a: 10 93 04 04 sts 0x0404, r17
servoMotorRight = SERVO_POS_MOTOR_STOP;
80e: 10 93 05 04 sts 0x0405, r17
if(++regulatorMeasureCounter == 5)
812: 80 91 42 04 lds r24, 0x0442
816: 8f 5f subi r24, 0xFF ; 255
818: 80 93 42 04 sts 0x0442, r24
81c: 85 30 cpi r24, 0x05 ; 5
81e: 09 f0 breq .+2 ; 0x822 <updateProgram+0x2ec>
820: b2 c1 rjmp .+868 ; 0xb86 <updateProgram+0x650>
{
lcdSetPos(0x00);
822: 80 e0 ldi r24, 0x00 ; 0
824: 0e 94 d3 07 call 0xfa6 ; 0xfa6 <lcdSetPos>
lcdWriteString("Posistion locked");
828: 84 e6 ldi r24, 0x64 ; 100
82a: 93 e0 ldi r25, 0x03 ; 3
82c: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
servoMotorLeft = SERVO_POS_MOTOR_STOP;
830: 10 93 04 04 sts 0x0404, r17
servoMotorRight = SERVO_POS_MOTOR_STOP;
834: 10 93 05 04 sts 0x0405, r17
tempDistanceToWall = tempDistance;
838: 80 91 31 04 lds r24, 0x0431
83c: 90 91 32 04 lds r25, 0x0432
840: 90 93 34 04 sts 0x0434, r25
844: 80 93 33 04 sts 0x0433, r24
progTimer = 50;
848: 82 e3 ldi r24, 0x32 ; 50
84a: 80 93 2e 04 sts 0x042E, r24
regulatorMeasureCounter = 0;
84e: 10 92 42 04 sts 0x0442, r1
852: 86 c1 rjmp .+780 ; 0xb60 <updateProgram+0x62a>
break;
case 13:
// Vrider 90grader
servoPing = SERVO_POS_CENTER;
854: 8c e8 ldi r24, 0x8C ; 140
856: 80 93 03 04 sts 0x0403, r24
if(tempLeftDistance > tempRightDistance)
85a: 20 91 37 04 lds r18, 0x0437
85e: 30 91 38 04 lds r19, 0x0438
862: 80 91 39 04 lds r24, 0x0439
866: 90 91 3a 04 lds r25, 0x043A
86a: 82 17 cp r24, r18
86c: 93 07 cpc r25, r19
86e: 98 f4 brcc .+38 ; 0x896 <updateProgram+0x360>
{
lcdSetPos(0x00);
870: 80 e0 ldi r24, 0x00 ; 0
872: 0e 94 d3 07 call 0xfa6 ; 0xfa6 <lcdSetPos>
lcdWriteString("Drive: Turn < ");
876: 85 e7 ldi r24, 0x75 ; 117
878: 93 e0 ldi r25, 0x03 ; 3
87a: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
servoMotorLeft = SERVO_POS_MOTOR_RE_FAST;
87e: 88 e6 ldi r24, 0x68 ; 104
880: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_FW_FAST;
884: 86 e8 ldi r24, 0x86 ; 134
886: 80 93 05 04 sts 0x0405, r24
servoPing = SERVO_POS_RIGHT_90;
88a: 83 e4 ldi r24, 0x43 ; 67
88c: 80 93 03 04 sts 0x0403, r24
regulatorMode = 0; // M<>ter <20>t h<>ger
890: 10 92 3f 04 sts 0x043F, r1
894: 13 c0 rjmp .+38 ; 0x8bc <updateProgram+0x386>
progTimer = 50;
}
else
{
lcdSetPos(0x00);
896: 80 e0 ldi r24, 0x00 ; 0
898: 0e 94 d3 07 call 0xfa6 ; 0xfa6 <lcdSetPos>
lcdWriteString("Drive: Turn > ");
89c: 84 e8 ldi r24, 0x84 ; 132
89e: 93 e0 ldi r25, 0x03 ; 3
8a0: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
servoMotorLeft = SERVO_POS_MOTOR_FW_FAST;
8a4: 86 e8 ldi r24, 0x86 ; 134
8a6: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_RE_FAST;
8aa: 88 e6 ldi r24, 0x68 ; 104
8ac: 80 93 05 04 sts 0x0405, r24
servoPing = SERVO_POS_LEFT_90;
8b0: 80 ed ldi r24, 0xD0 ; 208
8b2: 80 93 03 04 sts 0x0403, r24
regulatorMode = 1; // M<>ter <20>t v<>nster
8b6: 81 e0 ldi r24, 0x01 ; 1
8b8: 80 93 3f 04 sts 0x043F, r24
progTimer = 50;
8bc: 82 e3 ldi r24, 0x32 ; 50
8be: 19 c0 rjmp .+50 ; 0x8f2 <updateProgram+0x3bc>
break;
case 14:
// Stanna
servoMotorLeft = SERVO_POS_MOTOR_STOP;
8c0: 87 e7 ldi r24, 0x77 ; 119
8c2: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_STOP;
8c6: 80 93 05 04 sts 0x0405, r24
progTimer = 10;
8ca: 8a e0 ldi r24, 0x0A ; 10
8cc: 80 93 2e 04 sts 0x042E, r24
regulatorTimer = 2;
8d0: 82 e0 ldi r24, 0x02 ; 2
8d2: 80 93 40 04 sts 0x0440, r24
8d6: 18 c0 rjmp .+48 ; 0x908 <updateProgram+0x3d2>
break;
case 15:
// K<>r framm<6D>t
lcdSetPos(0x00);
8d8: 80 e0 ldi r24, 0x00 ; 0
8da: 0e 94 d3 07 call 0xfa6 ; 0xfa6 <lcdSetPos>
lcdWriteString("Drive: FORWARD ");
8de: 80 e2 ldi r24, 0x20 ; 32
8e0: 93 e0 ldi r25, 0x03 ; 3
8e2: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
servoMotorLeft = SERVO_POS_MOTOR_FW_FAST;
8e6: 86 e8 ldi r24, 0x86 ; 134
8e8: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_FW_FAST;
8ec: 80 93 05 04 sts 0x0405, r24
progTimer = 20;
8f0: 84 e1 ldi r24, 0x14 ; 20
8f2: 80 93 2e 04 sts 0x042E, r24
8f6: 34 c1 rjmp .+616 ; 0xb60 <updateProgram+0x62a>
break;
case 16:
// K<>r framm<6D>t
servoMotorLeft = SERVO_POS_MOTOR_FW_SOFT;
8f8: 8f e7 ldi r24, 0x7F ; 127
8fa: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_FW_SOFT;
8fe: 80 93 05 04 sts 0x0405, r24
progTimer = 10;
902: 8a e0 ldi r24, 0x0A ; 10
904: 80 93 2e 04 sts 0x042E, r24
progPosition++;
908: 81 e1 ldi r24, 0x11 ; 17
90a: 3b c1 rjmp .+630 ; 0xb82 <updateProgram+0x64c>
break;
case 17:
// M<>ter avst<73>nd
pingSendPing();
90c: 0e 94 8c 0b call 0x1718 ; 0x1718 <pingSendPing>
progTimer = 3;
910: 83 e0 ldi r24, 0x03 ; 3
912: 80 93 2e 04 sts 0x042E, r24
if(pingGetReady())
916: 0e 94 a7 0b call 0x174e ; 0x174e <pingGetReady>
91a: 88 23 and r24, r24
91c: 09 f4 brne .+2 ; 0x920 <updateProgram+0x3ea>
91e: 33 c1 rjmp .+614 ; 0xb86 <updateProgram+0x650>
{
tempDistance = pingGetDistance();
920: 0e 94 a0 0b call 0x1740 ; 0x1740 <pingGetDistance>
924: 90 93 32 04 sts 0x0432, r25
928: 80 93 31 04 sts 0x0431, r24
progTimer = 1;
92c: 81 e0 ldi r24, 0x01 ; 1
92e: e1 cf rjmp .-62 ; 0x8f2 <updateProgram+0x3bc>
break;
case 18:
// Reglerar 1meter fr<66>n v<>ggen
if(++regulatorCounter >= regulatorTimer)
930: 80 91 41 04 lds r24, 0x0441
934: 8f 5f subi r24, 0xFF ; 255
936: 80 93 41 04 sts 0x0441, r24
93a: 90 91 40 04 lds r25, 0x0440
93e: 89 17 cp r24, r25
940: 48 f0 brcs .+18 ; 0x954 <updateProgram+0x41e>
{
progPosition++;
942: 83 e1 ldi r24, 0x13 ; 19
944: 80 93 2f 04 sts 0x042F, r24
progTimer = 1;
948: 81 e0 ldi r24, 0x01 ; 1
94a: 80 93 2e 04 sts 0x042E, r24
regulatorCounter = 0;
94e: 10 92 41 04 sts 0x0441, r1
952: 19 c1 rjmp .+562 ; 0xb86 <updateProgram+0x650>
}
else
{
uint8_t calculateProgTimer = 0;
if (regulatorMode == 0) // Tittar h<>ger
954: 80 91 3f 04 lds r24, 0x043F
958: 88 23 and r24, r24
95a: 09 f0 breq .+2 ; 0x95e <updateProgram+0x428>
95c: 47 c0 rjmp .+142 ; 0x9ec <updateProgram+0x4b6>
{
lcdSetPos(0x00);
95e: 0e 94 d3 07 call 0xfa6 ; 0xfa6 <lcdSetPos>
lcdWriteString(" ]--- (1m) --->|");
962: 83 e9 ldi r24, 0x93 ; 147
964: 93 e0 ldi r25, 0x03 ; 3
966: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
if(tempDistance > DISTANCE_ONE_METER)
96a: 20 91 31 04 lds r18, 0x0431
96e: 30 91 32 04 lds r19, 0x0432
972: 87 e1 ldi r24, 0x17 ; 23
974: 21 37 cpi r18, 0x71 ; 113
976: 38 07 cpc r19, r24
978: 30 f0 brcs .+12 ; 0x986 <updateProgram+0x450>
showDistanceOnLCD((tempDistance-DISTANCE_ONE_METER),3,2);
97a: 42 e0 ldi r20, 0x02 ; 2
97c: 63 e0 ldi r22, 0x03 ; 3
97e: c9 01 movw r24, r18
980: 80 57 subi r24, 0x70 ; 112
982: 97 41 sbci r25, 0x17 ; 23
984: 06 c0 rjmp .+12 ; 0x992 <updateProgram+0x45c>
else
showDistanceOnLCD((DISTANCE_ONE_METER-tempDistance),2,2);
986: 42 e0 ldi r20, 0x02 ; 2
988: 62 e0 ldi r22, 0x02 ; 2
98a: 80 e7 ldi r24, 0x70 ; 112
98c: 97 e1 ldi r25, 0x17 ; 23
98e: 82 1b sub r24, r18
990: 93 0b sbc r25, r19
992: 0e 94 7c 01 call 0x2f8 ; 0x2f8 <showDistanceOnLCD>
if((tempDistance < tempLastDistanceToWall) && (tempDistance < (DISTANCE_ONE_METER -1000)))
996: 60 91 31 04 lds r22, 0x0431
99a: 70 91 32 04 lds r23, 0x0432
99e: 80 91 35 04 lds r24, 0x0435
9a2: 90 91 36 04 lds r25, 0x0436
9a6: 68 17 cp r22, r24
9a8: 79 07 cpc r23, r25
9aa: 70 f4 brcc .+28 ; 0x9c8 <updateProgram+0x492>
9ac: 23 e1 ldi r18, 0x13 ; 19
9ae: 68 38 cpi r22, 0x88 ; 136
9b0: 72 07 cpc r23, r18
9b2: 28 f4 brcc .+10 ; 0x9be <updateProgram+0x488>
{
// sv<73>ng v<>nster
servoMotorLeft = SERVO_POS_MOTOR_RE_FAST;
9b4: 88 e6 ldi r24, 0x68 ; 104
9b6: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_FW_FAST;
9ba: 86 e8 ldi r24, 0x86 ; 134
9bc: 4a c0 rjmp .+148 ; 0xa52 <updateProgram+0x51c>
progTimer = calculateProgTimer;
else
progTimer = 15;
}
else if((tempDistance < tempLastDistanceToWall) && (tempDistance < (DISTANCE_ONE_METER -10)))
9be: 66 56 subi r22, 0x66 ; 102
9c0: 77 41 sbci r23, 0x17 ; 23
9c2: 08 f0 brcs .+2 ; 0x9c6 <updateProgram+0x490>
9c4: 7c c0 rjmp .+248 ; 0xabe <updateProgram+0x588>
9c6: 73 c0 rjmp .+230 ; 0xaae <updateProgram+0x578>
servoMotorRight = SERVO_POS_MOTOR_FW_FAST;
progTimer = 5;
}
else if((tempDistance > tempLastDistanceToWall) && (tempDistance > (DISTANCE_ONE_METER+1000)))
9c8: 86 17 cp r24, r22
9ca: 97 07 cpc r25, r23
9cc: 08 f0 brcs .+2 ; 0x9d0 <updateProgram+0x49a>
9ce: 77 c0 rjmp .+238 ; 0xabe <updateProgram+0x588>
9d0: 8b e1 ldi r24, 0x1B ; 27
9d2: 69 35 cpi r22, 0x59 ; 89
9d4: 78 07 cpc r23, r24
9d6: 28 f0 brcs .+10 ; 0x9e2 <updateProgram+0x4ac>
{
// sv<73>ng h<>ger
servoMotorLeft = SERVO_POS_MOTOR_FW_FAST;
9d8: 86 e8 ldi r24, 0x86 ; 134
9da: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_RE_FAST;
9de: 88 e6 ldi r24, 0x68 ; 104
9e0: 4e c0 rjmp .+156 ; 0xa7e <updateProgram+0x548>
progTimer = calculateProgTimer;
else
progTimer = 15;
}
else if((tempDistance > tempLastDistanceToWall) && (tempDistance > (DISTANCE_ONE_METER+10)))
9e2: 6b 57 subi r22, 0x7B ; 123
9e4: 77 41 sbci r23, 0x17 ; 23
9e6: 08 f4 brcc .+2 ; 0x9ea <updateProgram+0x4b4>
9e8: 6a c0 rjmp .+212 ; 0xabe <updateProgram+0x588>
9ea: 39 c0 rjmp .+114 ; 0xa5e <updateProgram+0x528>
servoMotorRight = SERVO_POS_MOTOR_FW_SOFT;
progTimer = 4;
}
}
else if (regulatorMode == 1) // Tittar v<>nster
9ec: 81 30 cpi r24, 0x01 ; 1
9ee: 09 f0 breq .+2 ; 0x9f2 <updateProgram+0x4bc>
9f0: 6e c0 rjmp .+220 ; 0xace <updateProgram+0x598>
{
lcdSetPos(0x00);
9f2: 80 e0 ldi r24, 0x00 ; 0
9f4: 0e 94 d3 07 call 0xfa6 ; 0xfa6 <lcdSetPos>
lcdWriteString("|<--- (1m) ---[ ");
9f8: 84 ea ldi r24, 0xA4 ; 164
9fa: 93 e0 ldi r25, 0x03 ; 3
9fc: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
if(tempDistance > DISTANCE_ONE_METER)
a00: 20 91 31 04 lds r18, 0x0431
a04: 30 91 32 04 lds r19, 0x0432
a08: 47 e1 ldi r20, 0x17 ; 23
a0a: 21 37 cpi r18, 0x71 ; 113
a0c: 34 07 cpc r19, r20
a0e: 30 f0 brcs .+12 ; 0xa1c <updateProgram+0x4e6>
showDistanceOnLCD((tempDistance-DISTANCE_ONE_METER),2,2);
a10: 42 e0 ldi r20, 0x02 ; 2
a12: 62 e0 ldi r22, 0x02 ; 2
a14: c9 01 movw r24, r18
a16: 80 57 subi r24, 0x70 ; 112
a18: 97 41 sbci r25, 0x17 ; 23
a1a: 06 c0 rjmp .+12 ; 0xa28 <updateProgram+0x4f2>
else
showDistanceOnLCD((DISTANCE_ONE_METER-tempDistance),3,2);
a1c: 42 e0 ldi r20, 0x02 ; 2
a1e: 63 e0 ldi r22, 0x03 ; 3
a20: 80 e7 ldi r24, 0x70 ; 112
a22: 97 e1 ldi r25, 0x17 ; 23
a24: 82 1b sub r24, r18
a26: 93 0b sbc r25, r19
a28: 0e 94 7c 01 call 0x2f8 ; 0x2f8 <showDistanceOnLCD>
if((tempDistance < tempLastDistanceToWall) && (tempDistance < (DISTANCE_ONE_METER-1000)))
a2c: 60 91 31 04 lds r22, 0x0431
a30: 70 91 32 04 lds r23, 0x0432
a34: 80 91 35 04 lds r24, 0x0435
a38: 90 91 36 04 lds r25, 0x0436
a3c: 68 17 cp r22, r24
a3e: 79 07 cpc r23, r25
a40: 98 f4 brcc .+38 ; 0xa68 <updateProgram+0x532>
a42: 83 e1 ldi r24, 0x13 ; 19
a44: 68 38 cpi r22, 0x88 ; 136
a46: 78 07 cpc r23, r24
a48: 38 f4 brcc .+14 ; 0xa58 <updateProgram+0x522>
{
// sv<73>ng h<>ger
servoMotorLeft = SERVO_POS_MOTOR_FW_FAST;
a4a: 86 e8 ldi r24, 0x86 ; 134
a4c: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_RE_FAST;
a50: 88 e6 ldi r24, 0x68 ; 104
a52: 80 93 05 04 sts 0x0405, r24
a56: 26 c0 rjmp .+76 ; 0xaa4 <updateProgram+0x56e>
progTimer = calculateProgTimer;
else
progTimer = 15;
}
else if((tempDistance < tempLastDistanceToWall) && (tempDistance < (DISTANCE_ONE_METER-10)))
a58: 66 56 subi r22, 0x66 ; 102
a5a: 77 41 sbci r23, 0x17 ; 23
a5c: 80 f5 brcc .+96 ; 0xabe <updateProgram+0x588>
{
// sv<73>ng h<>ger
servoMotorLeft = SERVO_POS_MOTOR_FW_FAST;
a5e: 86 e8 ldi r24, 0x86 ; 134
a60: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_RE_FAST;
a64: 88 e6 ldi r24, 0x68 ; 104
a66: 27 c0 rjmp .+78 ; 0xab6 <updateProgram+0x580>
progTimer = 5;
}
else if((tempDistance > tempLastDistanceToWall) && (tempDistance > (DISTANCE_ONE_METER +1000)))
a68: 86 17 cp r24, r22
a6a: 97 07 cpc r25, r23
a6c: 40 f5 brcc .+80 ; 0xabe <updateProgram+0x588>
a6e: 4b e1 ldi r20, 0x1B ; 27
a70: 69 35 cpi r22, 0x59 ; 89
a72: 74 07 cpc r23, r20
a74: c8 f0 brcs .+50 ; 0xaa8 <updateProgram+0x572>
{
// sv<73>ng v<>nster
servoMotorLeft = SERVO_POS_MOTOR_RE_FAST;
a76: 88 e6 ldi r24, 0x68 ; 104
a78: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_FW_FAST;
a7c: 86 e8 ldi r24, 0x86 ; 134
a7e: 80 93 05 04 sts 0x0405, r24
calculateProgTimer = ((tempDistance - DISTANCE_ONE_METER)/40);
a82: 80 e0 ldi r24, 0x00 ; 0
a84: 90 e0 ldi r25, 0x00 ; 0
a86: 60 57 subi r22, 0x70 ; 112
a88: 77 41 sbci r23, 0x17 ; 23
a8a: 80 40 sbci r24, 0x00 ; 0
a8c: 90 40 sbci r25, 0x00 ; 0
a8e: 28 e2 ldi r18, 0x28 ; 40
a90: 30 e0 ldi r19, 0x00 ; 0
a92: 40 e0 ldi r20, 0x00 ; 0
a94: 50 e0 ldi r21, 0x00 ; 0
a96: 0e 94 e7 0b call 0x17ce ; 0x17ce <__udivmodsi4>
if(calculateProgTimer < 15)
a9a: 2f 30 cpi r18, 0x0F ; 15
a9c: 18 f4 brcc .+6 ; 0xaa4 <updateProgram+0x56e>
progTimer = calculateProgTimer;
a9e: 20 93 2e 04 sts 0x042E, r18
aa2: 15 c0 rjmp .+42 ; 0xace <updateProgram+0x598>
else
progTimer = 15;
aa4: 8f e0 ldi r24, 0x0F ; 15
aa6: 11 c0 rjmp .+34 ; 0xaca <updateProgram+0x594>
}
else if((tempDistance > tempLastDistanceToWall) && (tempDistance > (DISTANCE_ONE_METER +10)))
aa8: 6b 57 subi r22, 0x7B ; 123
aaa: 77 41 sbci r23, 0x17 ; 23
aac: 40 f0 brcs .+16 ; 0xabe <updateProgram+0x588>
{
// sv<73>ng v<>nster
servoMotorLeft = SERVO_POS_MOTOR_RE_FAST;
aae: 88 e6 ldi r24, 0x68 ; 104
ab0: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_FW_FAST;
ab4: 86 e8 ldi r24, 0x86 ; 134
ab6: 80 93 05 04 sts 0x0405, r24
progTimer = 5;
aba: 85 e0 ldi r24, 0x05 ; 5
abc: 06 c0 rjmp .+12 ; 0xaca <updateProgram+0x594>
}
else
{
servoMotorLeft = SERVO_POS_MOTOR_FW_SOFT;
abe: 8f e7 ldi r24, 0x7F ; 127
ac0: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_FW_SOFT;
ac4: 80 93 05 04 sts 0x0405, r24
progTimer = 4;
ac8: 84 e0 ldi r24, 0x04 ; 4
aca: 80 93 2e 04 sts 0x042E, r24
}
}
tempLastDistanceToWall = tempDistance;
ace: 80 91 31 04 lds r24, 0x0431
ad2: 90 91 32 04 lds r25, 0x0432
ad6: 90 93 36 04 sts 0x0436, r25
ada: 80 93 35 04 sts 0x0435, r24
progPosition--;
ade: 80 91 2f 04 lds r24, 0x042F
progPosition--;
ae2: 82 50 subi r24, 0x02 ; 2
ae4: 4e c0 rjmp .+156 ; 0xb82 <updateProgram+0x64c>
break;
case 19:
servoPing = SERVO_POS_CENTER;
ae6: 8c e8 ldi r24, 0x8C ; 140
ae8: 80 93 03 04 sts 0x0403, r24
servoMotorLeft = SERVO_POS_MOTOR_STOP;
aec: 87 e7 ldi r24, 0x77 ; 119
aee: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_STOP;
af2: 80 93 05 04 sts 0x0405, r24
progTimer = 35;
af6: 83 e2 ldi r24, 0x23 ; 35
af8: 80 93 2e 04 sts 0x042E, r24
progPosition++;
afc: 84 e1 ldi r24, 0x14 ; 20
afe: 41 c0 rjmp .+130 ; 0xb82 <updateProgram+0x64c>
break;
case 20:
progTimer = 3;
b00: 83 e0 ldi r24, 0x03 ; 3
b02: 80 93 2e 04 sts 0x042E, r24
pingSendPing();
b06: 0e 94 8c 0b call 0x1718 ; 0x1718 <pingSendPing>
if(pingGetReady())
b0a: 0e 94 a7 0b call 0x174e ; 0x174e <pingGetReady>
b0e: 88 23 and r24, r24
b10: d1 f1 breq .+116 ; 0xb86 <updateProgram+0x650>
{
tempDistance = pingGetDistance();
b12: 0e 94 a0 0b call 0x1740 ; 0x1740 <pingGetDistance>
b16: 90 93 32 04 sts 0x0432, r25
b1a: 80 93 31 04 sts 0x0431, r24
if(tempDistance < DISTANCE_ONE_METER)
b1e: 27 e1 ldi r18, 0x17 ; 23
b20: 80 37 cpi r24, 0x70 ; 112
b22: 92 07 cpc r25, r18
b24: 40 f4 brcc .+16 ; 0xb36 <updateProgram+0x600>
{
showDistanceOnLCD(0,0,1);
b26: 41 e0 ldi r20, 0x01 ; 1
b28: 60 e0 ldi r22, 0x00 ; 0
b2a: 80 e0 ldi r24, 0x00 ; 0
b2c: 90 e0 ldi r25, 0x00 ; 0
b2e: 0e 94 7c 01 call 0x2f8 ; 0x2f8 <showDistanceOnLCD>
progPosition = 2;
b32: 82 e0 ldi r24, 0x02 ; 2
b34: 26 c0 rjmp .+76 ; 0xb82 <updateProgram+0x64c>
b36: 9c 01 movw r18, r24
b38: 20 57 subi r18, 0x70 ; 112
b3a: 37 41 sbci r19, 0x17 ; 23
}
else if (tempDistance < (DISTANCE_ONE_METER*2))
b3c: 80 5e subi r24, 0xE0 ; 224
b3e: 9e 42 sbci r25, 0x2E ; 46
b40: 38 f4 brcc .+14 ; 0xb50 <updateProgram+0x61a>
{
showDistanceOnLCD(tempDistance-DISTANCE_ONE_METER,0,1);
b42: 41 e0 ldi r20, 0x01 ; 1
b44: 60 e0 ldi r22, 0x00 ; 0
b46: c9 01 movw r24, r18
b48: 0e 94 7c 01 call 0x2f8 ; 0x2f8 <showDistanceOnLCD>
regulatorTimer = 2;
b4c: 82 e0 ldi r24, 0x02 ; 2
b4e: 06 c0 rjmp .+12 ; 0xb5c <updateProgram+0x626>
progPosition++;
}
else
{
showDistanceOnLCD(tempDistance-DISTANCE_ONE_METER,0,1);
b50: 41 e0 ldi r20, 0x01 ; 1
b52: 60 e0 ldi r22, 0x00 ; 0
b54: c9 01 movw r24, r18
b56: 0e 94 7c 01 call 0x2f8 ; 0x2f8 <showDistanceOnLCD>
regulatorTimer = 10;
b5a: 8a e0 ldi r24, 0x0A ; 10
b5c: 80 93 40 04 sts 0x0440, r24
progPosition++;
b60: 80 91 2f 04 lds r24, 0x042F
b64: 8f 5f subi r24, 0xFF ; 255
b66: 0d c0 rjmp .+26 ; 0xb82 <updateProgram+0x64c>
break;
case 21:
if (regulatorMode == 0) // Tittar h<>ger
b68: 80 91 3f 04 lds r24, 0x043F
b6c: 88 23 and r24, r24
b6e: 11 f4 brne .+4 ; 0xb74 <updateProgram+0x63e>
{
servoPing = SERVO_POS_RIGHT_90;
b70: 83 e4 ldi r24, 0x43 ; 67
b72: 01 c0 rjmp .+2 ; 0xb76 <updateProgram+0x640>
}
else
{
servoPing = SERVO_POS_LEFT_90;
b74: 80 ed ldi r24, 0xD0 ; 208
b76: 80 93 03 04 sts 0x0403, r24
}
progTimer = 5;
b7a: 85 e0 ldi r24, 0x05 ; 5
b7c: 80 93 2e 04 sts 0x042E, r24
progPosition = 15;
b80: 8f e0 ldi r24, 0x0F ; 15
b82: 80 93 2f 04 sts 0x042F, r24
break;
}
progCounter = 0;
b86: 10 92 2d 04 sts 0x042D, r1
}
}
// Program for robot AI
if (roboActive == 2)
b8a: 20 91 3b 04 lds r18, 0x043B
b8e: 22 30 cpi r18, 0x02 ; 2
b90: 09 f0 breq .+2 ; 0xb94 <updateProgram+0x65e>
b92: 01 c1 rjmp .+514 ; 0xd96 <updateProgram+0x860>
{
// Program(2) for random RFID serach
if (++progCounter >= progTimer)
b94: 80 91 2d 04 lds r24, 0x042D
b98: 8f 5f subi r24, 0xFF ; 255
b9a: 80 93 2d 04 sts 0x042D, r24
b9e: 90 91 2e 04 lds r25, 0x042E
ba2: 89 17 cp r24, r25
ba4: 08 f4 brcc .+2 ; 0xba8 <updateProgram+0x672>
ba6: f7 c0 rjmp .+494 ; 0xd96 <updateProgram+0x860>
{
switch (progPosition)
ba8: 80 91 2f 04 lds r24, 0x042F
bac: 84 30 cpi r24, 0x04 ; 4
bae: 09 f4 brne .+2 ; 0xbb2 <updateProgram+0x67c>
bb0: 68 c0 rjmp .+208 ; 0xc82 <updateProgram+0x74c>
bb2: 85 30 cpi r24, 0x05 ; 5
bb4: 50 f4 brcc .+20 ; 0xbca <updateProgram+0x694>
bb6: 81 30 cpi r24, 0x01 ; 1
bb8: 11 f1 breq .+68 ; 0xbfe <updateProgram+0x6c8>
bba: 81 30 cpi r24, 0x01 ; 1
bbc: c8 f0 brcs .+50 ; 0xbf0 <updateProgram+0x6ba>
bbe: 82 30 cpi r24, 0x02 ; 2
bc0: 59 f1 breq .+86 ; 0xc18 <updateProgram+0x6e2>
bc2: 83 30 cpi r24, 0x03 ; 3
bc4: 09 f0 breq .+2 ; 0xbc8 <updateProgram+0x692>
bc6: e5 c0 rjmp .+458 ; 0xd92 <updateProgram+0x85c>
bc8: 4e c0 rjmp .+156 ; 0xc66 <updateProgram+0x730>
bca: 87 30 cpi r24, 0x07 ; 7
bcc: 09 f4 brne .+2 ; 0xbd0 <updateProgram+0x69a>
bce: 7c c0 rjmp .+248 ; 0xcc8 <updateProgram+0x792>
bd0: 88 30 cpi r24, 0x08 ; 8
bd2: 38 f4 brcc .+14 ; 0xbe2 <updateProgram+0x6ac>
bd4: 85 30 cpi r24, 0x05 ; 5
bd6: 09 f4 brne .+2 ; 0xbda <updateProgram+0x6a4>
bd8: 5d c0 rjmp .+186 ; 0xc94 <updateProgram+0x75e>
bda: 86 30 cpi r24, 0x06 ; 6
bdc: 09 f0 breq .+2 ; 0xbe0 <updateProgram+0x6aa>
bde: d9 c0 rjmp .+434 ; 0xd92 <updateProgram+0x85c>
be0: 61 c0 rjmp .+194 ; 0xca4 <updateProgram+0x76e>
be2: 88 30 cpi r24, 0x08 ; 8
be4: 09 f4 brne .+2 ; 0xbe8 <updateProgram+0x6b2>
be6: 78 c0 rjmp .+240 ; 0xcd8 <updateProgram+0x7a2>
be8: 89 30 cpi r24, 0x09 ; 9
bea: 09 f0 breq .+2 ; 0xbee <updateProgram+0x6b8>
bec: d2 c0 rjmp .+420 ; 0xd92 <updateProgram+0x85c>
bee: c6 c0 rjmp .+396 ; 0xd7c <updateProgram+0x846>
{
case 0:
lcdClearDisplay();
bf0: 0e 94 df 07 call 0xfbe ; 0xfbe <lcdClearDisplay>
lcdSetLayout(1);
bf4: 81 e0 ldi r24, 0x01 ; 1
bf6: 0e 94 a8 07 call 0xf50 ; 0xf50 <lcdSetLayout>
progTimer = 1;
bfa: 81 e0 ldi r24, 0x01 ; 1
bfc: b9 c0 rjmp .+370 ; 0xd70 <updateProgram+0x83a>
break;
case 1:
lcdSetPos(0x00);
bfe: 80 e0 ldi r24, 0x00 ; 0
c00: 0e 94 d3 07 call 0xfa6 ; 0xfa6 <lcdSetPos>
lcdWriteString("Drive: FORWARD ");
c04: 80 e2 ldi r24, 0x20 ; 32
c06: 93 e0 ldi r25, 0x03 ; 3
c08: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
servoMotorLeft = SERVO_POS_MOTOR_FW_FAST;
c0c: 86 e8 ldi r24, 0x86 ; 134
c0e: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_FW_FAST;
c12: 80 93 05 04 sts 0x0405, r24
c16: 56 c0 rjmp .+172 ; 0xcc4 <updateProgram+0x78e>
break;
case 2:
servoMotorLeft = SERVO_POS_MOTOR_FW_SOFT;
c18: 8f e7 ldi r24, 0x7F ; 127
c1a: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_FW_SOFT;
c1e: 80 93 05 04 sts 0x0405, r24
pingSendPing();
c22: 0e 94 8c 0b call 0x1718 ; 0x1718 <pingSendPing>
progTimer = 3;
c26: 83 e0 ldi r24, 0x03 ; 3
c28: 80 93 2e 04 sts 0x042E, r24
if(pingGetReady())
c2c: 0e 94 a7 0b call 0x174e ; 0x174e <pingGetReady>
c30: 88 23 and r24, r24
c32: 09 f4 brne .+2 ; 0xc36 <updateProgram+0x700>
c34: ae c0 rjmp .+348 ; 0xd92 <updateProgram+0x85c>
{
tempDistance = pingGetDistance();
c36: 0e 94 a0 0b call 0x1740 ; 0x1740 <pingGetDistance>
c3a: 90 93 32 04 sts 0x0432, r25
c3e: 80 93 31 04 sts 0x0431, r24
if(tempDistance < DISTANCE_TO_STOP)
c42: 25 e1 ldi r18, 0x15 ; 21
c44: 8c 37 cpi r24, 0x7C ; 124
c46: 92 07 cpc r25, r18
c48: 38 f4 brcc .+14 ; 0xc58 <updateProgram+0x722>
{
showDistanceOnLCD(0,0,2);
c4a: 42 e0 ldi r20, 0x02 ; 2
c4c: 60 e0 ldi r22, 0x00 ; 0
c4e: 80 e0 ldi r24, 0x00 ; 0
c50: 90 e0 ldi r25, 0x00 ; 0
c52: 0e 94 7c 01 call 0x2f8 ; 0x2f8 <showDistanceOnLCD>
c56: 8e c0 rjmp .+284 ; 0xd74 <updateProgram+0x83e>
progPosition++;
}
else
{
showDistanceOnLCD(tempDistance-DISTANCE_TO_STOP,0,2);
c58: 42 e0 ldi r20, 0x02 ; 2
c5a: 60 e0 ldi r22, 0x00 ; 0
c5c: 8c 57 subi r24, 0x7C ; 124
c5e: 95 41 sbci r25, 0x15 ; 21
c60: 0e 94 7c 01 call 0x2f8 ; 0x2f8 <showDistanceOnLCD>
c64: 96 c0 rjmp .+300 ; 0xd92 <updateProgram+0x85c>
break;
case 3:
lcdSetPos(0x00);
c66: 80 e0 ldi r24, 0x00 ; 0
c68: 0e 94 d3 07 call 0xfa6 ; 0xfa6 <lcdSetPos>
lcdWriteString("Drive: STOP ");
c6c: 81 e3 ldi r24, 0x31 ; 49
c6e: 93 e0 ldi r25, 0x03 ; 3
c70: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
// Stop and breake
servoMotorLeft = SERVO_POS_MOTOR_STOP;
servoMotorRight = SERVO_POS_MOTOR_STOP;
servoMotorLeft = SERVO_POS_MOTOR_RE;
c74: 8c e6 ldi r24, 0x6C ; 108
c76: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_RE;
c7a: 80 93 05 04 sts 0x0405, r24
progTimer = 50;
c7e: 82 e3 ldi r24, 0x32 ; 50
c80: 77 c0 rjmp .+238 ; 0xd70 <updateProgram+0x83a>
break;
case 4:
servoMotorLeft = SERVO_POS_MOTOR_STOP;
c82: 87 e7 ldi r24, 0x77 ; 119
c84: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_STOP;
c88: 80 93 05 04 sts 0x0405, r24
progTimer = 2;
c8c: 20 93 2e 04 sts 0x042E, r18
progPosition++;
c90: 85 e0 ldi r24, 0x05 ; 5
c92: 7d c0 rjmp .+250 ; 0xd8e <updateProgram+0x858>
break;
case 5:
servoPing = SERVO_POS_LEFT_45;
c94: 8e ea ldi r24, 0xAE ; 174
c96: 80 93 03 04 sts 0x0403, r24
progTimer = 20;
c9a: 84 e1 ldi r24, 0x14 ; 20
c9c: 80 93 2e 04 sts 0x042E, r24
progPosition++;
ca0: 86 e0 ldi r24, 0x06 ; 6
ca2: 75 c0 rjmp .+234 ; 0xd8e <updateProgram+0x858>
break;
case 6:
pingSendPing();
ca4: 0e 94 8c 0b call 0x1718 ; 0x1718 <pingSendPing>
progTimer = 4;
ca8: 84 e0 ldi r24, 0x04 ; 4
caa: 80 93 2e 04 sts 0x042E, r24
if(pingGetReady())
cae: 0e 94 a7 0b call 0x174e ; 0x174e <pingGetReady>
cb2: 88 23 and r24, r24
cb4: 09 f4 brne .+2 ; 0xcb8 <updateProgram+0x782>
cb6: 6d c0 rjmp .+218 ; 0xd92 <updateProgram+0x85c>
{
tempLeftDistance = pingGetDistance();
cb8: 0e 94 a0 0b call 0x1740 ; 0x1740 <pingGetDistance>
cbc: 90 93 38 04 sts 0x0438, r25
cc0: 80 93 37 04 sts 0x0437, r24
progTimer = 20;
cc4: 84 e1 ldi r24, 0x14 ; 20
cc6: 54 c0 rjmp .+168 ; 0xd70 <updateProgram+0x83a>
break;
case 7:
servoPing = SERVO_POS_RIGHT_45;
cc8: 87 e6 ldi r24, 0x67 ; 103
cca: 80 93 03 04 sts 0x0403, r24
progTimer = 40;
cce: 88 e2 ldi r24, 0x28 ; 40
cd0: 80 93 2e 04 sts 0x042E, r24
progPosition++;
cd4: 88 e0 ldi r24, 0x08 ; 8
cd6: 5b c0 rjmp .+182 ; 0xd8e <updateProgram+0x858>
break;
case 8:
pingSendPing();
cd8: 0e 94 8c 0b call 0x1718 ; 0x1718 <pingSendPing>
progTimer = 4;
cdc: 84 e0 ldi r24, 0x04 ; 4
cde: 80 93 2e 04 sts 0x042E, r24
if(pingGetReady())
ce2: 0e 94 a7 0b call 0x174e ; 0x174e <pingGetReady>
ce6: 88 23 and r24, r24
ce8: 09 f4 brne .+2 ; 0xcec <updateProgram+0x7b6>
cea: 53 c0 rjmp .+166 ; 0xd92 <updateProgram+0x85c>
{
tempRightDistance = pingGetDistance();
cec: 0e 94 a0 0b call 0x1740 ; 0x1740 <pingGetDistance>
cf0: 9c 01 movw r18, r24
cf2: 90 93 3a 04 sts 0x043A, r25
cf6: 80 93 39 04 sts 0x0439, r24
servoPing = SERVO_POS_CENTER;
cfa: 8c e8 ldi r24, 0x8C ; 140
cfc: 80 93 03 04 sts 0x0403, r24
if((tempLeftDistance < DISTANCE_TO_STOP )
d00: 80 91 37 04 lds r24, 0x0437
d04: 90 91 38 04 lds r25, 0x0438
d08: 45 e1 ldi r20, 0x15 ; 21
d0a: 8c 37 cpi r24, 0x7C ; 124
d0c: 94 07 cpc r25, r20
d0e: 98 f4 brcc .+38 ; 0xd36 <updateProgram+0x800>
d10: 45 e1 ldi r20, 0x15 ; 21
d12: 2c 37 cpi r18, 0x7C ; 124
d14: 34 07 cpc r19, r20
d16: 78 f4 brcc .+30 ; 0xd36 <updateProgram+0x800>
&& (tempRightDistance < DISTANCE_TO_STOP))
{
lcdSetPos(0x00);
d18: 80 e0 ldi r24, 0x00 ; 0
d1a: 0e 94 d3 07 call 0xfa6 ; 0xfa6 <lcdSetPos>
lcdWriteString("Drive: Turn <<< ");
d1e: 85 eb ldi r24, 0xB5 ; 181
d20: 93 e0 ldi r25, 0x03 ; 3
d22: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
servoMotorLeft = SERVO_POS_MOTOR_RE_FAST;
d26: 88 e6 ldi r24, 0x68 ; 104
d28: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_FW_FAST;
d2c: 86 e8 ldi r24, 0x86 ; 134
d2e: 80 93 05 04 sts 0x0405, r24
progTimer = 70;
d32: 86 e4 ldi r24, 0x46 ; 70
d34: 1d c0 rjmp .+58 ; 0xd70 <updateProgram+0x83a>
}
else if(tempLeftDistance > tempRightDistance)
d36: 28 17 cp r18, r24
d38: 39 07 cpc r19, r25
d3a: 60 f4 brcc .+24 ; 0xd54 <updateProgram+0x81e>
{
lcdSetPos(0x00);
d3c: 80 e0 ldi r24, 0x00 ; 0
d3e: 0e 94 d3 07 call 0xfa6 ; 0xfa6 <lcdSetPos>
lcdWriteString("Drive: Turn < ");
d42: 86 ec ldi r24, 0xC6 ; 198
d44: 93 e0 ldi r25, 0x03 ; 3
d46: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
servoMotorLeft = SERVO_POS_MOTOR_RE_FAST;
d4a: 88 e6 ldi r24, 0x68 ; 104
d4c: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_FW_FAST;
d50: 86 e8 ldi r24, 0x86 ; 134
d52: 0b c0 rjmp .+22 ; 0xd6a <updateProgram+0x834>
progTimer = 40;
}
else
{
lcdSetPos(0x00);
d54: 80 e0 ldi r24, 0x00 ; 0
d56: 0e 94 d3 07 call 0xfa6 ; 0xfa6 <lcdSetPos>
lcdWriteString("Drive: Turn > ");
d5a: 87 ed ldi r24, 0xD7 ; 215
d5c: 93 e0 ldi r25, 0x03 ; 3
d5e: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
servoMotorLeft = SERVO_POS_MOTOR_FW_FAST;
d62: 86 e8 ldi r24, 0x86 ; 134
d64: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_RE_FAST;
d68: 88 e6 ldi r24, 0x68 ; 104
d6a: 80 93 05 04 sts 0x0405, r24
progTimer = 40;
d6e: 88 e2 ldi r24, 0x28 ; 40
d70: 80 93 2e 04 sts 0x042E, r24
}
progPosition++;
d74: 80 91 2f 04 lds r24, 0x042F
d78: 8f 5f subi r24, 0xFF ; 255
d7a: 09 c0 rjmp .+18 ; 0xd8e <updateProgram+0x858>
break;
case 9:
servoMotorLeft = SERVO_POS_MOTOR_STOP;
d7c: 87 e7 ldi r24, 0x77 ; 119
d7e: 80 93 04 04 sts 0x0404, r24
servoMotorRight = SERVO_POS_MOTOR_STOP;
d82: 80 93 05 04 sts 0x0405, r24
progTimer = 10;
d86: 8a e0 ldi r24, 0x0A ; 10
d88: 80 93 2e 04 sts 0x042E, r24
progPosition = 1;
d8c: 81 e0 ldi r24, 0x01 ; 1
d8e: 80 93 2f 04 sts 0x042F, r24
break;
}
progCounter = 0;
d92: 10 92 2d 04 sts 0x042D, r1
}
}
if (roboActive == 3)
d96: 80 91 3b 04 lds r24, 0x043B
d9a: 83 30 cpi r24, 0x03 ; 3
d9c: 09 f0 breq .+2 ; 0xda0 <updateProgram+0x86a>
d9e: 46 c0 rjmp .+140 ; 0xe2c <updateProgram+0x8f6>
{
// Program(2) for random RFID serach
if (++progCounter >= progTimer)
da0: 80 91 2d 04 lds r24, 0x042D
da4: 8f 5f subi r24, 0xFF ; 255
da6: 80 93 2d 04 sts 0x042D, r24
daa: 90 91 2e 04 lds r25, 0x042E
dae: 89 17 cp r24, r25
db0: e8 f1 brcs .+122 ; 0xe2c <updateProgram+0x8f6>
{
switch (progPosition)
db2: 80 91 2f 04 lds r24, 0x042F
db6: 88 23 and r24, r24
db8: 19 f0 breq .+6 ; 0xdc0 <updateProgram+0x88a>
dba: 81 30 cpi r24, 0x01 ; 1
dbc: a9 f5 brne .+106 ; 0xe28 <updateProgram+0x8f2>
dbe: 1c c0 rjmp .+56 ; 0xdf8 <updateProgram+0x8c2>
{
case 0:
lcdClearDisplay();
dc0: 0e 94 df 07 call 0xfbe ; 0xfbe <lcdClearDisplay>
lcdSetLayout(1);
dc4: 81 e0 ldi r24, 0x01 ; 1
dc6: 0e 94 a8 07 call 0xf50 ; 0xf50 <lcdSetLayout>
lcdSetPos(0x00);
dca: 80 e0 ldi r24, 0x00 ; 0
dcc: 0e 94 d3 07 call 0xfa6 ; 0xfa6 <lcdSetPos>
lcdWriteString("Servo: forward ");
dd0: 88 ee ldi r24, 0xE8 ; 232
dd2: 93 e0 ldi r25, 0x03 ; 3
dd4: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
lcdSetPos(0x10);
dd8: 80 e1 ldi r24, 0x10 ; 16
dda: 0e 94 d3 07 call 0xfa6 ; 0xfa6 <lcdSetPos>
lcdWriteString("Distance: ");
dde: 88 ef ldi r24, 0xF8 ; 248
de0: 93 e0 ldi r25, 0x03 ; 3
de2: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
progTimer = 1;
de6: 81 e0 ldi r24, 0x01 ; 1
de8: 80 93 2e 04 sts 0x042E, r24
progPosition++;
dec: 80 91 2f 04 lds r24, 0x042F
df0: 8f 5f subi r24, 0xFF ; 255
df2: 80 93 2f 04 sts 0x042F, r24
df6: 18 c0 rjmp .+48 ; 0xe28 <updateProgram+0x8f2>
break;
case 1:
pingSendPing();
df8: 0e 94 8c 0b call 0x1718 ; 0x1718 <pingSendPing>
progTimer = 10;
dfc: 8a e0 ldi r24, 0x0A ; 10
dfe: 80 93 2e 04 sts 0x042E, r24
if(pingGetReady())
e02: 0e 94 a7 0b call 0x174e ; 0x174e <pingGetReady>
e06: 88 23 and r24, r24
e08: 79 f0 breq .+30 ; 0xe28 <updateProgram+0x8f2>
{
tempDistance = pingGetDistance();
e0a: 0e 94 a0 0b call 0x1740 ; 0x1740 <pingGetDistance>
e0e: 90 93 32 04 sts 0x0432, r25
e12: 80 93 31 04 sts 0x0431, r24
lcdSetPos(0x1A);
e16: 8a e1 ldi r24, 0x1A ; 26
e18: 0e 94 d3 07 call 0xfa6 ; 0xfa6 <lcdSetPos>
lcdWriteHexAsDecimal(tempDistance);
e1c: 80 91 31 04 lds r24, 0x0431
e20: 90 91 32 04 lds r25, 0x0432
e24: 0e 94 80 08 call 0x1100 ; 0x1100 <lcdWriteHexAsDecimal>
}
break;
}
progCounter = 0;
e28: 10 92 2d 04 sts 0x042D, r1
e2c: 1f 91 pop r17
e2e: 08 95 ret
00000e30 <main>:
}
/*================================================================================================
Main
================================================================================================*/
int main (void){
e30: cf 93 push r28
e32: df 93 push r29
cli(); // Disable global interrupt
e34: f8 94 cli
initIO();
e36: 0e 94 e8 00 call 0x1d0 ; 0x1d0 <initIO>
lcdInit();
e3a: 0e 94 40 09 call 0x1280 ; 0x1280 <lcdInit>
rfIdInit();
e3e: 0e 94 b0 09 call 0x1360 ; 0x1360 <rfIdInit>
roboMSPInit();
e42: 0e 94 30 0a call 0x1460 ; 0x1460 <roboMSPInit>
pingInit();
e46: 0e 94 ab 0b call 0x1756 ; 0x1756 <pingInit>
lcdSetIntensity(50);
e4a: 82 e3 ldi r24, 0x32 ; 50
e4c: 0e 94 99 07 call 0xf32 ; 0xf32 <lcdSetIntensity>
lcdSetLayout(2);
e50: 82 e0 ldi r24, 0x02 ; 2
e52: 0e 94 a8 07 call 0xf50 ; 0xf50 <lcdSetLayout>
lcdWriteStringP(menuTable[0]);
e56: 8c e9 ldi r24, 0x9C ; 156
e58: 90 e0 ldi r25, 0x00 ; 0
e5a: 0e 94 2d 08 call 0x105a ; 0x105a <lcdWriteStringP>
rfIdDisable();
e5e: 0e 94 bb 09 call 0x1376 ; 0x1376 <rfIdDisable>
roboMSPDisable();
e62: 0e 94 42 0a call 0x1484 ; 0x1484 <roboMSPDisable>
sei(); // Enable global interrupt
e66: 78 94 sei
e68: c0 e6 ldi r28, 0x60 ; 96
e6a: d1 e0 ldi r29, 0x01 ; 1
while(1){
if(progDoUpdate)
e6c: 80 91 30 04 lds r24, 0x0430
e70: 88 23 and r24, r24
e72: 21 f0 breq .+8 ; 0xe7c <main+0x4c>
{
progDoUpdate = 0;
e74: 10 92 30 04 sts 0x0430, r1
updateProgram();
e78: 0e 94 9b 02 call 0x536 ; 0x536 <updateProgram>
}
// Active-mode 1 (left switch lower position)
if (!bit_is_set(PINA,PA4))
e7c: cc 99 sbic 0x19, 4 ; 25
e7e: 08 c0 rjmp .+16 ; 0xe90 <main+0x60>
{
if(switchOneCheck)
e80: 80 91 3d 04 lds r24, 0x043D
e84: 88 23 and r24, r24
e86: 59 f1 breq .+86 ; 0xede <main+0xae>
{
activateRobot(3);
e88: 83 e0 ldi r24, 0x03 ; 3
e8a: 0e 94 5b 01 call 0x2b6 ; 0x2b6 <activateRobot>
e8e: 25 c0 rjmp .+74 ; 0xeda <main+0xaa>
switchOneCheck = 0;
}
}
// Active-mode 2 (left switch middle position)
else if ((bit_is_set(PINA,PA5)) && (bit_is_set(PINA,PA4)))
e90: cd 9b sbis 0x19, 5 ; 25
e92: 10 c0 rjmp .+32 ; 0xeb4 <main+0x84>
e94: cc 9b sbis 0x19, 4 ; 25
e96: 0e c0 rjmp .+28 ; 0xeb4 <main+0x84>
{
if(!switchOneCheck)
e98: 80 91 3d 04 lds r24, 0x043D
e9c: 88 23 and r24, r24
e9e: f9 f4 brne .+62 ; 0xede <main+0xae>
{
deactivateRobot();
ea0: 0e 94 6f 01 call 0x2de ; 0x2de <deactivateRobot>
rfEnable = 0;
ea4: 10 92 3c 04 sts 0x043C, r1
switchOneCheck = 1;
ea8: 81 e0 ldi r24, 0x01 ; 1
eaa: 80 93 3d 04 sts 0x043D, r24
main();
eae: 0e 94 18 07 call 0xe30 ; 0xe30 <main>
eb2: 15 c0 rjmp .+42 ; 0xede <main+0xae>
}
}
// Active-mode 3 (left switch upper position)
else if (!bit_is_set(PINA,PA5))
eb4: cd 99 sbic 0x19, 5 ; 25
eb6: 13 c0 rjmp .+38 ; 0xede <main+0xae>
{
if(switchOneCheck)
eb8: 80 91 3d 04 lds r24, 0x043D
ebc: 88 23 and r24, r24
ebe: 79 f0 breq .+30 ; 0xede <main+0xae>
{
lcdSetLayout(0);
ec0: 80 e0 ldi r24, 0x00 ; 0
ec2: 0e 94 a8 07 call 0xf50 ; 0xf50 <lcdSetLayout>
lcdWriteStringP(menuTable[4]);
ec6: ce 01 movw r24, r28
ec8: 0e 94 2d 08 call 0x105a ; 0x105a <lcdWriteStringP>
rfEnable = 1;
ecc: 81 e0 ldi r24, 0x01 ; 1
ece: 80 93 3c 04 sts 0x043C, r24
rfIdEnable();
ed2: 0e 94 bf 09 call 0x137e ; 0x137e <rfIdEnable>
roboMSPEnable();
ed6: 0e 94 45 0a call 0x148a ; 0x148a <roboMSPEnable>
switchOneCheck = 0;
eda: 10 92 3d 04 sts 0x043D, r1
}
}
// Active-mode 1 (left switch lower position)
if (!bit_is_set(PINA,PA6))
ede: ce 99 sbic 0x19, 6 ; 25
ee0: 06 c0 rjmp .+12 ; 0xeee <main+0xbe>
{
if(switchTwoCheck)
ee2: 80 91 3e 04 lds r24, 0x043E
ee6: 88 23 and r24, r24
ee8: 09 f2 breq .-126 ; 0xe6c <main+0x3c>
{
activateRobot(1);
eea: 81 e0 ldi r24, 0x01 ; 1
eec: 1b c0 rjmp .+54 ; 0xf24 <main+0xf4>
switchTwoCheck = 0;
}
}
// Active-mode 2 (left switch middle position)
else if ((bit_is_set(PINA,PA7)) && (bit_is_set(PINA,PA6)))
eee: cf 9b sbis 0x19, 7 ; 25
ef0: 11 c0 rjmp .+34 ; 0xf14 <main+0xe4>
ef2: ce 9b sbis 0x19, 6 ; 25
ef4: 0f c0 rjmp .+30 ; 0xf14 <main+0xe4>
{
if(!switchTwoCheck)
ef6: 80 91 3e 04 lds r24, 0x043E
efa: 88 23 and r24, r24
efc: 09 f0 breq .+2 ; 0xf00 <main+0xd0>
efe: b6 cf rjmp .-148 ; 0xe6c <main+0x3c>
{
deactivateRobot();
f00: 0e 94 6f 01 call 0x2de ; 0x2de <deactivateRobot>
rfEnable = 0;
f04: 10 92 3c 04 sts 0x043C, r1
switchTwoCheck = 1;
f08: 81 e0 ldi r24, 0x01 ; 1
f0a: 80 93 3e 04 sts 0x043E, r24
main();
f0e: 0e 94 18 07 call 0xe30 ; 0xe30 <main>
f12: ac cf rjmp .-168 ; 0xe6c <main+0x3c>
}
}
// Active-mode 3 (left switch upper position)
else if (!bit_is_set(PINA,PA7))
f14: cf 99 sbic 0x19, 7 ; 25
f16: aa cf rjmp .-172 ; 0xe6c <main+0x3c>
{
if(switchTwoCheck)
f18: 80 91 3e 04 lds r24, 0x043E
f1c: 88 23 and r24, r24
f1e: 09 f4 brne .+2 ; 0xf22 <main+0xf2>
f20: a5 cf rjmp .-182 ; 0xe6c <main+0x3c>
{
activateRobot(2);
f22: 82 e0 ldi r24, 0x02 ; 2
f24: 0e 94 5b 01 call 0x2b6 ; 0x2b6 <activateRobot>
switchTwoCheck = 0;
f28: 10 92 3e 04 sts 0x043E, r1
f2c: 9f cf rjmp .-194 ; 0xe6c <main+0x3c>
00000f2e <lcdEngToSwe>:
data=0x83;
break;
}
return(data);
}
f2e: 99 27 eor r25, r25
f30: 08 95 ret
00000f32 <lcdSetIntensity>:
Return: -
------------------------------------------------------------------------------------------------*/
void lcdSetIntensity (uint8_t intensity)
{
OCR0 = intensity;
f32: 81 bf out 0x31, r24 ; 49
f34: 08 95 ret
00000f36 <lcdWriteIns>:
Input: cData
Return: -
------------------------------------------------------------------------------------------------*/
void lcdWriteIns (uint8_t data)
{
f36: 1f 93 push r17
f38: 18 2f mov r17, r24
spiSetLowSpeed();
f3a: 0e 94 f9 0a call 0x15f2 ; 0x15f2 <spiSetLowSpeed>
spiSelectDeviceIO(LCD_CS);
f3e: 80 e0 ldi r24, 0x00 ; 0
f40: 0e 94 fc 0a call 0x15f8 ; 0x15f8 <spiSelectDeviceIO>
LCD_PORT &= ~(1<<LCD_RS);
f44: c1 98 cbi 0x18, 1 ; 24
spiWrite(data);
f46: 81 2f mov r24, r17
f48: 0e 94 ef 0a call 0x15de ; 0x15de <spiWrite>
f4c: 1f 91 pop r17
f4e: 08 95 ret
00000f50 <lcdSetLayout>:
Return: -
------------------------------------------------------------------------------------------------*/
void lcdSetLayout (uint8_t layoutType)
{
switch(layoutType)
f50: 81 30 cpi r24, 0x01 ; 1
f52: 51 f0 breq .+20 ; 0xf68 <lcdSetLayout+0x18>
f54: 81 30 cpi r24, 0x01 ; 1
f56: 18 f0 brcs .+6 ; 0xf5e <lcdSetLayout+0xe>
f58: 82 30 cpi r24, 0x02 ; 2
f5a: f9 f4 brne .+62 ; 0xf9a <lcdSetLayout+0x4a>
f5c: 12 c0 rjmp .+36 ; 0xf82 <lcdSetLayout+0x32>
{
case 0: // 3 lines
lcdWriteIns(0x39);
f5e: 89 e3 ldi r24, 0x39 ; 57
f60: 0e 94 9b 07 call 0xf36 ; 0xf36 <lcdWriteIns>
lcdWriteIns(0x1D); // bias = 1/4 , 3 line mode
f64: 8d e1 ldi r24, 0x1D ; 29
f66: 0a c0 rjmp .+20 ; 0xf7c <lcdSetLayout+0x2c>
break;
case 1: // 2 lines, Double font on lower position
lcdWriteIns(0x39);
f68: 89 e3 ldi r24, 0x39 ; 57
f6a: 0e 94 9b 07 call 0xf36 ; 0xf36 <lcdWriteIns>
lcdWriteIns(0x1C); // bias = 1/4 , 2 line mode
f6e: 8c e1 ldi r24, 0x1C ; 28
f70: 0e 94 9b 07 call 0xf36 ; 0xf36 <lcdWriteIns>
lcdWriteIns(0x3E);
f74: 8e e3 ldi r24, 0x3E ; 62
f76: 0e 94 9b 07 call 0xf36 ; 0xf36 <lcdWriteIns>
lcdWriteIns(0x10);
f7a: 80 e1 ldi r24, 0x10 ; 16
f7c: 0e 94 9b 07 call 0xf36 ; 0xf36 <lcdWriteIns>
f80: 08 95 ret
break;
case 2: // 2 lines, Double font on upper position
lcdWriteIns(0x39);
f82: 89 e3 ldi r24, 0x39 ; 57
f84: 0e 94 9b 07 call 0xf36 ; 0xf36 <lcdWriteIns>
lcdWriteIns(0x1C); // bias = 1/4 , 2 line mode
f88: 8c e1 ldi r24, 0x1C ; 28
f8a: 0e 94 9b 07 call 0xf36 ; 0xf36 <lcdWriteIns>
lcdWriteIns(0x3E);
f8e: 8e e3 ldi r24, 0x3E ; 62
f90: 0e 94 9b 07 call 0xf36 ; 0xf36 <lcdWriteIns>
lcdWriteIns(0x18);
f94: 88 e1 ldi r24, 0x18 ; 24
f96: 0e 94 9b 07 call 0xf36 ; 0xf36 <lcdWriteIns>
f9a: 08 95 ret
00000f9c <lcdSetContrast>:
Return: -
------------------------------------------------------------------------------------------------*/
void lcdSetContrast (uint8_t contrastValue)
{
lcdWriteIns(0x70|(0x0F & contrastValue));
f9c: 8f 70 andi r24, 0x0F ; 15
f9e: 80 67 ori r24, 0x70 ; 112
fa0: 0e 94 9b 07 call 0xf36 ; 0xf36 <lcdWriteIns>
fa4: 08 95 ret
00000fa6 <lcdSetPos>:
Return: -
------------------------------------------------------------------------------------------------*/
void lcdSetPos (uint8_t address)
{
lcdWriteIns(0x80|address);
fa6: 80 68 ori r24, 0x80 ; 128
fa8: 0e 94 9b 07 call 0xf36 ; 0xf36 <lcdWriteIns>
fac: 08 95 ret
00000fae <lcdReturnHome>:
Return: -
------------------------------------------------------------------------------------------------*/
void lcdReturnHome (void)
{
lcdWriteIns(0x02);
fae: 82 e0 ldi r24, 0x02 ; 2
fb0: 0e 94 9b 07 call 0xf36 ; 0xf36 <lcdWriteIns>
fb4: 80 e4 ldi r24, 0x40 ; 64
fb6: 9f e1 ldi r25, 0x1F ; 31
fb8: 01 97 sbiw r24, 0x01 ; 1
fba: f1 f7 brne .-4 ; 0xfb8 <lcdReturnHome+0xa>
fbc: 08 95 ret
00000fbe <lcdClearDisplay>:
Return: -
------------------------------------------------------------------------------------------------*/
void lcdClearDisplay (void)
{
lcdWriteIns(0x01);
fbe: 81 e0 ldi r24, 0x01 ; 1
fc0: 0e 94 9b 07 call 0xf36 ; 0xf36 <lcdWriteIns>
fc4: 80 e4 ldi r24, 0x40 ; 64
fc6: 9f e1 ldi r25, 0x1F ; 31
fc8: 01 97 sbiw r24, 0x01 ; 1
fca: f1 f7 brne .-4 ; 0xfc8 <lcdClearDisplay+0xa>
fcc: 08 95 ret
00000fce <lcdSetBlink>:
Return: -
------------------------------------------------------------------------------------------------*/
void lcdSetBlink (uint8_t value)
{
switch (value)
fce: 88 23 and r24, r24
fd0: 31 f0 breq .+12 ; 0xfde <lcdSetBlink+0x10>
fd2: 81 30 cpi r24, 0x01 ; 1
fd4: 49 f4 brne .+18 ; 0xfe8 <lcdSetBlink+0x1a>
{
case ON:
lcdTempReg |= 0x01;
fd6: 80 91 43 04 lds r24, 0x0443
fda: 81 60 ori r24, 0x01 ; 1
fdc: 03 c0 rjmp .+6 ; 0xfe4 <lcdSetBlink+0x16>
break;
case OFF:
lcdTempReg &= ~(0x01);
fde: 80 91 43 04 lds r24, 0x0443
fe2: 8e 7f andi r24, 0xFE ; 254
fe4: 80 93 43 04 sts 0x0443, r24
break;
}
lcdWriteIns(0x08|lcdTempReg);
fe8: 80 91 43 04 lds r24, 0x0443
fec: 88 60 ori r24, 0x08 ; 8
fee: 0e 94 9b 07 call 0xf36 ; 0xf36 <lcdWriteIns>
ff2: 08 95 ret
00000ff4 <lcdSetCursor>:
Return: -
------------------------------------------------------------------------------------------------*/
void lcdSetCursor (uint8_t value)
{
switch (value)
ff4: 88 23 and r24, r24
ff6: 31 f0 breq .+12 ; 0x1004 <lcdSetCursor+0x10>
ff8: 81 30 cpi r24, 0x01 ; 1
ffa: 49 f4 brne .+18 ; 0x100e <lcdSetCursor+0x1a>
{
case ON:
lcdTempReg |= 0x02;
ffc: 80 91 43 04 lds r24, 0x0443
1000: 82 60 ori r24, 0x02 ; 2
1002: 03 c0 rjmp .+6 ; 0x100a <lcdSetCursor+0x16>
break;
case OFF:
lcdTempReg &= ~(0x02);
1004: 80 91 43 04 lds r24, 0x0443
1008: 8d 7f andi r24, 0xFD ; 253
100a: 80 93 43 04 sts 0x0443, r24
break;
}
lcdWriteIns(0x08|lcdTempReg);
100e: 80 91 43 04 lds r24, 0x0443
1012: 88 60 ori r24, 0x08 ; 8
1014: 0e 94 9b 07 call 0xf36 ; 0xf36 <lcdWriteIns>
1018: 08 95 ret
0000101a <lcdSetDisplay>:
Return: -
------------------------------------------------------------------------------------------------*/
void lcdSetDisplay (uint8_t value)
{
switch (value)
101a: 88 23 and r24, r24
101c: 31 f0 breq .+12 ; 0x102a <lcdSetDisplay+0x10>
101e: 81 30 cpi r24, 0x01 ; 1
1020: 49 f4 brne .+18 ; 0x1034 <lcdSetDisplay+0x1a>
{
case ON:
lcdTempReg |= 0x04;
1022: 80 91 43 04 lds r24, 0x0443
1026: 84 60 ori r24, 0x04 ; 4
1028: 03 c0 rjmp .+6 ; 0x1030 <lcdSetDisplay+0x16>
break;
case OFF:
lcdTempReg &= ~(0x04);
102a: 80 91 43 04 lds r24, 0x0443
102e: 8b 7f andi r24, 0xFB ; 251
1030: 80 93 43 04 sts 0x0443, r24
break;
}
lcdWriteIns(0x08|lcdTempReg);
1034: 80 91 43 04 lds r24, 0x0443
1038: 88 60 ori r24, 0x08 ; 8
103a: 0e 94 9b 07 call 0xf36 ; 0xf36 <lcdWriteIns>
103e: 08 95 ret
00001040 <lcdWriteChar>:
Input: cData
Return: -
------------------------------------------------------------------------------------------------*/
void lcdWriteChar (uint8_t data)
{
1040: 1f 93 push r17
1042: 18 2f mov r17, r24
spiSetLowSpeed();
1044: 0e 94 f9 0a call 0x15f2 ; 0x15f2 <spiSetLowSpeed>
spiSelectDeviceIO(LCD_CS);
1048: 80 e0 ldi r24, 0x00 ; 0
104a: 0e 94 fc 0a call 0x15f8 ; 0x15f8 <spiSelectDeviceIO>
LCD_PORT |= (1<<LCD_RS);
104e: c1 9a sbi 0x18, 1 ; 24
spiWrite(lcdEngToSwe(data));
1050: 81 2f mov r24, r17
1052: 0e 94 ef 0a call 0x15de ; 0x15de <spiWrite>
1056: 1f 91 pop r17
1058: 08 95 ret
0000105a <lcdWriteStringP>:
Input: *stringPointer (int[])
Return: -
------------------------------------------------------------------------------------------------*/
void lcdWriteStringP (const uint8_t *progmemStringPointer)
{
105a: cf 93 push r28
105c: df 93 push r29
105e: ec 01 movw r28, r24
1060: 02 c0 rjmp .+4 ; 0x1066 <lcdWriteStringP+0xc>
register uint8_t c;
while((c = pgm_read_byte(progmemStringPointer++)))
{
lcdWriteChar(c);
1062: 0e 94 20 08 call 0x1040 ; 0x1040 <lcdWriteChar>
1066: fe 01 movw r30, r28
void lcdWriteStringP (const uint8_t *progmemStringPointer)
{
register uint8_t c;
while((c = pgm_read_byte(progmemStringPointer++)))
1068: 21 96 adiw r28, 0x01 ; 1
106a: 84 91 lpm r24, Z
106c: 88 23 and r24, r24
106e: c9 f7 brne .-14 ; 0x1062 <lcdWriteStringP+0x8>
1070: df 91 pop r29
1072: cf 91 pop r28
1074: 08 95 ret
00001076 <lcdWriteString>:
Input: *stringPointer (int[])
Return: -
------------------------------------------------------------------------------------------------*/
void lcdWriteString (const uint8_t *stringPointer)
{
1076: cf 93 push r28
1078: df 93 push r29
107a: ec 01 movw r28, r24
107c: 02 c0 rjmp .+4 ; 0x1082 <lcdWriteString+0xc>
register uint8_t c;
while((c = *stringPointer++))
{
lcdWriteChar(c);
107e: 0e 94 20 08 call 0x1040 ; 0x1040 <lcdWriteChar>
void lcdWriteString (const uint8_t *stringPointer)
{
register uint8_t c;
while((c = *stringPointer++))
1082: 89 91 ld r24, Y+
1084: 88 23 and r24, r24
1086: d9 f7 brne .-10 ; 0x107e <lcdWriteString+0x8>
1088: df 91 pop r29
108a: cf 91 pop r28
108c: 08 95 ret
0000108e <lcdWriteHex>:
Description: Writes hex to LCD
Input: hexValue
Output: -
----------------------------------------------------------------------------------------------------------*/
void lcdWriteHex(uint16_t hexValue)
{
108e: cf 93 push r28
1090: df 93 push r29
1092: cd b7 in r28, 0x3d ; 61
1094: de b7 in r29, 0x3e ; 62
1096: 27 97 sbiw r28, 0x07 ; 7
1098: 0f b6 in r0, 0x3f ; 63
109a: f8 94 cli
109c: de bf out 0x3e, r29 ; 62
109e: 0f be out 0x3f, r0 ; 63
10a0: cd bf out 0x3d, r28 ; 61
10a2: bc 01 movw r22, r24
uint8_t tempString[7];
uint8_t n=0;
uint8_t i;
tempString[n] = '0';
10a4: 80 e3 ldi r24, 0x30 ; 48
10a6: 89 83 std Y+1, r24 ; 0x01
n++;
tempString[n] = 'x';
10a8: 88 e7 ldi r24, 0x78 ; 120
10aa: 8a 83 std Y+2, r24 ; 0x02
10ac: fe 01 movw r30, r28
10ae: 33 96 adiw r30, 0x03 ; 3
10b0: 4c e0 ldi r20, 0x0C ; 12
10b2: 50 e0 ldi r21, 0x00 ; 0
10b4: 33 e0 ldi r19, 0x03 ; 3
n++;
for(i=0;i<4;i++)
{
if(((hexValue>>(12-(i*4)))&0x000F)>0x0009)
10b6: cb 01 movw r24, r22
10b8: 04 2e mov r0, r20
10ba: 02 c0 rjmp .+4 ; 0x10c0 <lcdWriteHex+0x32>
10bc: 96 95 lsr r25
10be: 87 95 ror r24
10c0: 0a 94 dec r0
10c2: e2 f7 brpl .-8 ; 0x10bc <lcdWriteHex+0x2e>
10c4: 28 2f mov r18, r24
10c6: 2f 70 andi r18, 0x0F ; 15
10c8: 8f 70 andi r24, 0x0F ; 15
10ca: 90 70 andi r25, 0x00 ; 0
10cc: 0a 97 sbiw r24, 0x0a ; 10
10ce: 10 f0 brcs .+4 ; 0x10d4 <lcdWriteHex+0x46>
{
tempString[n] = (((hexValue>>(12-(i*4)))&0x000F)+0x37);
10d0: 29 5c subi r18, 0xC9 ; 201
10d2: 01 c0 rjmp .+2 ; 0x10d6 <lcdWriteHex+0x48>
n++;
}
else
{
tempString[n] = (((hexValue>>(12-(i*4)))&0x000F)|0x30);
10d4: 20 63 ori r18, 0x30 ; 48
10d6: 20 83 st Z, r18
10d8: 44 50 subi r20, 0x04 ; 4
10da: 50 40 sbci r21, 0x00 ; 0
10dc: 3f 5f subi r19, 0xFF ; 255
10de: 31 96 adiw r30, 0x01 ; 1
tempString[n] = '0';
n++;
tempString[n] = 'x';
n++;
for(i=0;i<4;i++)
10e0: 37 30 cpi r19, 0x07 ; 7
10e2: 49 f7 brne .-46 ; 0x10b6 <lcdWriteHex+0x28>
tempString[n] = (((hexValue>>(12-(i*4)))&0x000F)|0x30);
n++;
}
}
tempString[n] = '\0';
10e4: 1f 82 std Y+7, r1 ; 0x07
lcdWriteString(tempString);
10e6: ce 01 movw r24, r28
10e8: 01 96 adiw r24, 0x01 ; 1
10ea: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
10ee: 27 96 adiw r28, 0x07 ; 7
10f0: 0f b6 in r0, 0x3f ; 63
10f2: f8 94 cli
10f4: de bf out 0x3e, r29 ; 62
10f6: 0f be out 0x3f, r0 ; 63
10f8: cd bf out 0x3d, r28 ; 61
10fa: df 91 pop r29
10fc: cf 91 pop r28
10fe: 08 95 ret
00001100 <lcdWriteHexAsDecimal>:
Description: Writes hex value as decimal to LCD
Input: sensorValue
Output: -
----------------------------------------------------------------------------------------------------------*/
void lcdWriteHexAsDecimal(uint16_t hexValue)
{
1100: 8f 92 push r8
1102: 9f 92 push r9
1104: af 92 push r10
1106: bf 92 push r11
1108: cf 92 push r12
110a: df 92 push r13
110c: ef 92 push r14
110e: ff 92 push r15
1110: 0f 93 push r16
1112: 1f 93 push r17
1114: cf 93 push r28
1116: df 93 push r29
1118: cd b7 in r28, 0x3d ; 61
111a: de b7 in r29, 0x3e ; 62
111c: 25 97 sbiw r28, 0x05 ; 5
111e: 0f b6 in r0, 0x3f ; 63
1120: f8 94 cli
1122: de bf out 0x3e, r29 ; 62
1124: 0f be out 0x3f, r0 ; 63
1126: cd bf out 0x3d, r28 ; 61
1128: 8c 01 movw r16, r24
uint8_t tempString[5]={" "};
112a: de 01 movw r26, r28
112c: 11 96 adiw r26, 0x01 ; 1
112e: e8 e0 ldi r30, 0x08 ; 8
1130: f4 e0 ldi r31, 0x04 ; 4
1132: 85 e0 ldi r24, 0x05 ; 5
1134: 01 90 ld r0, Z+
1136: 0d 92 st X+, r0
1138: 81 50 subi r24, 0x01 ; 1
113a: e1 f7 brne .-8 ; 0x1134 <lcdWriteHexAsDecimal+0x34>
uint8_t secondDigit = 0;
uint8_t thirdDigit = 0;
uint8_t fourthDigit = 0;
uint8_t fifthDigit = 0;
firstDigit = (hexValue/10000);
113c: c8 01 movw r24, r16
113e: 60 e1 ldi r22, 0x10 ; 16
1140: 77 e2 ldi r23, 0x27 ; 39
1142: 0e 94 d3 0b call 0x17a6 ; 0x17a6 <__udivmodhi4>
1146: fb 01 movw r30, r22
1148: e6 2e mov r14, r22
secondDigit = ((hexValue-(firstDigit*10000))/1000);
114a: 26 2f mov r18, r22
114c: 33 27 eor r19, r19
114e: 80 e1 ldi r24, 0x10 ; 16
1150: 97 e2 ldi r25, 0x27 ; 39
1152: 28 9f mul r18, r24
1154: 60 01 movw r12, r0
1156: 29 9f mul r18, r25
1158: d0 0c add r13, r0
115a: 38 9f mul r19, r24
115c: d0 0c add r13, r0
115e: 11 24 eor r1, r1
1160: c8 01 movw r24, r16
1162: 8c 19 sub r24, r12
1164: 9d 09 sbc r25, r13
1166: 68 ee ldi r22, 0xE8 ; 232
1168: 73 e0 ldi r23, 0x03 ; 3
116a: 0e 94 d3 0b call 0x17a6 ; 0x17a6 <__udivmodhi4>
116e: f6 2e mov r15, r22
thirdDigit = ((hexValue-(firstDigit*10000+(secondDigit*1000)))/100);
1170: 26 2f mov r18, r22
1172: 33 27 eor r19, r19
1174: 88 ee ldi r24, 0xE8 ; 232
1176: 93 e0 ldi r25, 0x03 ; 3
1178: 28 9f mul r18, r24
117a: 40 01 movw r8, r0
117c: 29 9f mul r18, r25
117e: 90 0c add r9, r0
1180: 38 9f mul r19, r24
1182: 90 0c add r9, r0
1184: 11 24 eor r1, r1
1186: 94 01 movw r18, r8
1188: 2c 0d add r18, r12
118a: 3d 1d adc r19, r13
118c: c8 01 movw r24, r16
118e: 82 1b sub r24, r18
1190: 93 0b sbc r25, r19
1192: 64 e6 ldi r22, 0x64 ; 100
1194: 70 e0 ldi r23, 0x00 ; 0
1196: 0e 94 d3 0b call 0x17a6 ; 0x17a6 <__udivmodhi4>
119a: 46 2f mov r20, r22
fourthDigit = ((hexValue-(firstDigit*10000+(secondDigit*1000)+(thirdDigit*100)))/10);
119c: 84 e6 ldi r24, 0x64 ; 100
119e: 68 9f mul r22, r24
11a0: 50 01 movw r10, r0
11a2: 11 24 eor r1, r1
11a4: 2a 0d add r18, r10
11a6: 3b 1d adc r19, r11
11a8: c8 01 movw r24, r16
11aa: 82 1b sub r24, r18
11ac: 93 0b sbc r25, r19
11ae: 6a e0 ldi r22, 0x0A ; 10
11b0: 70 e0 ldi r23, 0x00 ; 0
11b2: 0e 94 d3 0b call 0x17a6 ; 0x17a6 <__udivmodhi4>
fifthDigit = (hexValue-(firstDigit*10000+(secondDigit*1000)+(thirdDigit*100)+(fourthDigit*10)));
uint8_t n = 0;
if(firstDigit)
11b6: ee 23 and r30, r30
11b8: 11 f4 brne .+4 ; 0x11be <lcdWriteHexAsDecimal+0xbe>
11ba: 30 e0 ldi r19, 0x00 ; 0
11bc: 04 c0 rjmp .+8 ; 0x11c6 <lcdWriteHexAsDecimal+0xc6>
{
tempString[n] = (0x30|firstDigit);
11be: 8e 2f mov r24, r30
11c0: 80 63 ori r24, 0x30 ; 48
11c2: 89 83 std Y+1, r24 ; 0x01
11c4: 31 e0 ldi r19, 0x01 ; 1
n++;
}
if(secondDigit||firstDigit)
11c6: ff 20 and r15, r15
11c8: 11 f4 brne .+4 ; 0x11ce <lcdWriteHexAsDecimal+0xce>
11ca: ee 20 and r14, r14
11cc: 39 f0 breq .+14 ; 0x11dc <lcdWriteHexAsDecimal+0xdc>
{
tempString[n] = (0x30|secondDigit);
11ce: fe 01 movw r30, r28
11d0: e3 0f add r30, r19
11d2: f1 1d adc r31, r1
11d4: 8f 2d mov r24, r15
11d6: 80 63 ori r24, 0x30 ; 48
11d8: 81 83 std Z+1, r24 ; 0x01
n++;
11da: 3f 5f subi r19, 0xFF ; 255
}
if(thirdDigit||secondDigit||firstDigit)
11dc: 44 23 and r20, r20
11de: 21 f4 brne .+8 ; 0x11e8 <lcdWriteHexAsDecimal+0xe8>
11e0: ff 20 and r15, r15
11e2: 11 f4 brne .+4 ; 0x11e8 <lcdWriteHexAsDecimal+0xe8>
11e4: ee 20 and r14, r14
11e6: 39 f0 breq .+14 ; 0x11f6 <lcdWriteHexAsDecimal+0xf6>
{
tempString[n] = (0x30|thirdDigit);
11e8: fe 01 movw r30, r28
11ea: e3 0f add r30, r19
11ec: f1 1d adc r31, r1
11ee: 84 2f mov r24, r20
11f0: 80 63 ori r24, 0x30 ; 48
11f2: 81 83 std Z+1, r24 ; 0x01
n++;
11f4: 3f 5f subi r19, 0xFF ; 255
}
if(fourthDigit||thirdDigit||secondDigit||firstDigit)
11f6: 66 23 and r22, r22
11f8: 31 f4 brne .+12 ; 0x1206 <lcdWriteHexAsDecimal+0x106>
11fa: 44 23 and r20, r20
11fc: 21 f4 brne .+8 ; 0x1206 <lcdWriteHexAsDecimal+0x106>
11fe: ff 20 and r15, r15
1200: 11 f4 brne .+4 ; 0x1206 <lcdWriteHexAsDecimal+0x106>
1202: ee 20 and r14, r14
1204: 39 f0 breq .+14 ; 0x1214 <lcdWriteHexAsDecimal+0x114>
{
tempString[n] = (0x30|fourthDigit);
1206: fe 01 movw r30, r28
1208: e3 0f add r30, r19
120a: f1 1d adc r31, r1
120c: 86 2f mov r24, r22
120e: 80 63 ori r24, 0x30 ; 48
1210: 81 83 std Z+1, r24 ; 0x01
n++;
1212: 3f 5f subi r19, 0xFF ; 255
}
tempString[n] = (0x30|fifthDigit);
1214: ae 01 movw r20, r28
1216: 4f 5f subi r20, 0xFF ; 255
1218: 5f 4f sbci r21, 0xFF ; 255
121a: fa 01 movw r30, r20
121c: e3 0f add r30, r19
121e: f1 1d adc r31, r1
1220: 20 2f mov r18, r16
1222: 2c 19 sub r18, r12
1224: 28 19 sub r18, r8
1226: 2a 19 sub r18, r10
1228: 8a e0 ldi r24, 0x0A ; 10
122a: 68 9f mul r22, r24
122c: c0 01 movw r24, r0
122e: 11 24 eor r1, r1
1230: 28 1b sub r18, r24
1232: 20 63 ori r18, 0x30 ; 48
1234: 20 83 st Z, r18
n++;
1236: 23 2f mov r18, r19
1238: 04 c0 rjmp .+8 ; 0x1242 <lcdWriteHexAsDecimal+0x142>
while(n<5)
{
tempString[n] = ' ';
123a: ae 0f add r26, r30
123c: bf 1f adc r27, r31
123e: 80 e2 ldi r24, 0x20 ; 32
1240: 8c 93 st X, r24
n++;
1242: 2f 5f subi r18, 0xFF ; 255
1244: da 01 movw r26, r20
1246: e2 2f mov r30, r18
1248: ff 27 eor r31, r31
n++;
}
tempString[n] = (0x30|fifthDigit);
n++;
while(n<5)
124a: 25 30 cpi r18, 0x05 ; 5
124c: b0 f3 brcs .-20 ; 0x123a <lcdWriteHexAsDecimal+0x13a>
{
tempString[n] = ' ';
n++;
}
tempString[n] = '\0';
124e: e4 0f add r30, r20
1250: f5 1f adc r31, r21
1252: 10 82 st Z, r1
lcdWriteString(tempString);
1254: ca 01 movw r24, r20
1256: 0e 94 3b 08 call 0x1076 ; 0x1076 <lcdWriteString>
125a: 25 96 adiw r28, 0x05 ; 5
125c: 0f b6 in r0, 0x3f ; 63
125e: f8 94 cli
1260: de bf out 0x3e, r29 ; 62
1262: 0f be out 0x3f, r0 ; 63
1264: cd bf out 0x3d, r28 ; 61
1266: df 91 pop r29
1268: cf 91 pop r28
126a: 1f 91 pop r17
126c: 0f 91 pop r16
126e: ff 90 pop r15
1270: ef 90 pop r14
1272: df 90 pop r13
1274: cf 90 pop r12
1276: bf 90 pop r11
1278: af 90 pop r10
127a: 9f 90 pop r9
127c: 8f 90 pop r8
127e: 08 95 ret
00001280 <lcdInit>:
Output: -
------------------------------------------------------------------------------------------------*/
void lcdInit (void)
{
spiInit();
1280: 0e 94 06 0b call 0x160c ; 0x160c <spiInit>
//LCD I/O
LCD_DDR |= (1<<LCD_BLED)|(1<<LCD_RS); // Set LCD related pins output
1284: 87 b3 in r24, 0x17 ; 23
1286: 83 60 ori r24, 0x03 ; 3
1288: 87 bb out 0x17, r24 ; 23
TCCR0 |= (1<<COM01)|(1<<WGM01)|(1<<WGM00)|(1<<CS01); // Timer0 set as fast PWM, set clock rate to fck/8
128a: 83 b7 in r24, 0x33 ; 51
128c: 8a 66 ori r24, 0x6A ; 106
128e: 83 bf out 0x33, r24 ; 51
//LCD init
lcdSetLayout(0);
1290: 80 e0 ldi r24, 0x00 ; 0
1292: 0e 94 a8 07 call 0xf50 ; 0xf50 <lcdSetLayout>
lcdWriteIns(0x50); // booster off, contrast C5, set C4
1296: 80 e5 ldi r24, 0x50 ; 80
1298: 0e 94 9b 07 call 0xf36 ; 0xf36 <lcdWriteIns>
lcdWriteIns(0x6C); // set voltage follower and gain
129c: 8c e6 ldi r24, 0x6C ; 108
129e: 0e 94 9b 07 call 0xf36 ; 0xf36 <lcdWriteIns>
lcdWriteIns(0x06); // cursor auto-increment right
12a2: 86 e0 ldi r24, 0x06 ; 6
12a4: 0e 94 9b 07 call 0xf36 ; 0xf36 <lcdWriteIns>
lcdSetDisplay(ON);
12a8: 81 e0 ldi r24, 0x01 ; 1
12aa: 0e 94 0d 08 call 0x101a ; 0x101a <lcdSetDisplay>
lcdSetCursor(OFF);
12ae: 80 e0 ldi r24, 0x00 ; 0
12b0: 0e 94 fa 07 call 0xff4 ; 0xff4 <lcdSetCursor>
lcdSetBlink(OFF);
12b4: 80 e0 ldi r24, 0x00 ; 0
12b6: 0e 94 e7 07 call 0xfce ; 0xfce <lcdSetBlink>
lcdSetContrast(6);
12ba: 86 e0 ldi r24, 0x06 ; 6
12bc: 0e 94 ce 07 call 0xf9c ; 0xf9c <lcdSetContrast>
lcdClearDisplay();
12c0: 0e 94 df 07 call 0xfbe ; 0xfbe <lcdClearDisplay>
Return: -
------------------------------------------------------------------------------------------------*/
void lcdSetIntensity (uint8_t intensity)
{
OCR0 = intensity;
12c4: 11 be out 0x31, r1 ; 49
12c6: 08 95 ret
000012c8 <rfIdGetTag>:
Input: -
Return: pointer to rfIdTagBuffer
------------------------------------------------------------------------------------------------*/
uint8_t* rfIdGetTag( void )
{
rfIdGotTag = 0;
12c8: 10 92 45 04 sts 0x0445, r1
//PORT_RFID |= (1<<RFID_ENABLE);
return rfIdTagBuffer;
}
12cc: 86 e4 ldi r24, 0x46 ; 70
12ce: 94 e0 ldi r25, 0x04 ; 4
12d0: 08 95 ret
000012d2 <rfIdClearBuffer>:
Input: -
Return: -
------------------------------------------------------------------------------------------------*/
void rfIdClearBuffer( void )
{
rfIdByteCount = 0;
12d2: 10 92 44 04 sts 0x0444, r1
PORT_RFID &= ~(1<<RFID_ENABLE);
12d6: 95 98 cbi 0x12, 5 ; 18
12d8: 08 95 ret
000012da <rfIdGetTagPresent>:
Input: -
Return: 1 if true, else 0
------------------------------------------------------------------------------------------------*/
uint8_t rfIdGetTagPresent( void )
{
12da: 80 91 45 04 lds r24, 0x0445
return rfIdGotTag;
}
12de: 99 27 eor r25, r25
12e0: 08 95 ret
000012e2 <__vector_19>:
Description: UART(0) Receive Complete Interrupt
Input: -
Output: -
------------------------------------------------------------------------------------------------*/
SIGNAL (SIG_USART0_RECV){
12e2: 1f 92 push r1
12e4: 0f 92 push r0
12e6: 0f b6 in r0, 0x3f ; 63
12e8: 0f 92 push r0
12ea: 11 24 eor r1, r1
12ec: 2f 93 push r18
12ee: 3f 93 push r19
12f0: 4f 93 push r20
12f2: 5f 93 push r21
12f4: 6f 93 push r22
12f6: 7f 93 push r23
12f8: 8f 93 push r24
12fa: 9f 93 push r25
12fc: af 93 push r26
12fe: bf 93 push r27
1300: ef 93 push r30
1302: ff 93 push r31
uint8_t data = usart0Receive();
1304: 0e 94 30 0b call 0x1660 ; 0x1660 <usart0Receive>
if (rfIdByteCount == 0)
1308: 90 91 44 04 lds r25, 0x0444
130c: 99 23 and r25, r25
130e: 31 f4 brne .+12 ; 0x131c <__vector_19+0x3a>
{
if (data == START_BYTE)
1310: 8a 30 cpi r24, 0x0A ; 10
1312: a9 f4 brne .+42 ; 0x133e <__vector_19+0x5c>
{
rfIdByteCount++;
1314: 81 e0 ldi r24, 0x01 ; 1
1316: 80 93 44 04 sts 0x0444, r24
131a: 11 c0 rjmp .+34 ; 0x133e <__vector_19+0x5c>
}
}
else if (rfIdByteCount < 11)
131c: 9b 30 cpi r25, 0x0B ; 11
131e: 48 f4 brcc .+18 ; 0x1332 <__vector_19+0x50>
{
rfIdTagBuffer[rfIdByteCount - 1] = data;
1320: e9 2f mov r30, r25
1322: ff 27 eor r31, r31
1324: eb 5b subi r30, 0xBB ; 187
1326: fb 4f sbci r31, 0xFB ; 251
1328: 80 83 st Z, r24
rfIdByteCount++;
132a: 9f 5f subi r25, 0xFF ; 255
132c: 90 93 44 04 sts 0x0444, r25
1330: 06 c0 rjmp .+12 ; 0x133e <__vector_19+0x5c>
}
else if (rfIdByteCount == 11)
1332: 9b 30 cpi r25, 0x0B ; 11
1334: 21 f4 brne .+8 ; 0x133e <__vector_19+0x5c>
{
PORT_RFID |= (1<<RFID_ENABLE);
1336: 95 9a sbi 0x12, 5 ; 18
rfIdGotTag = 1;
1338: 81 e0 ldi r24, 0x01 ; 1
133a: 80 93 45 04 sts 0x0445, r24
133e: ff 91 pop r31
1340: ef 91 pop r30
1342: bf 91 pop r27
1344: af 91 pop r26
1346: 9f 91 pop r25
1348: 8f 91 pop r24
134a: 7f 91 pop r23
134c: 6f 91 pop r22
134e: 5f 91 pop r21
1350: 4f 91 pop r20
1352: 3f 91 pop r19
1354: 2f 91 pop r18
1356: 0f 90 pop r0
1358: 0f be out 0x3f, r0 ; 63
135a: 0f 90 pop r0
135c: 1f 90 pop r1
135e: 18 95 reti
00001360 <rfIdInit>:
Input: -
Return: -
------------------------------------------------------------------------------------------------*/
void rfIdInit(void)
{
usart0Init();
1360: 0e 94 3d 0b call 0x167a ; 0x167a <usart0Init>
usart0SetBaud(USART0_BAUD_RATE);
1364: 80 e6 ldi r24, 0x60 ; 96
1366: 99 e0 ldi r25, 0x09 ; 9
1368: 0e 94 10 0b call 0x1620 ; 0x1620 <usart0SetBaud>
rfIdByteCount = 0;
136c: 10 92 44 04 sts 0x0444, r1
DDR_RFID |= (1<<RFID_ENABLE);
1370: 8d 9a sbi 0x11, 5 ; 17
PORT_RFID &= ~(1<<RFID_ENABLE);
1372: 95 98 cbi 0x12, 5 ; 18
1374: 08 95 ret
00001376 <rfIdDisable>:
Input: -
Return: -
------------------------------------------------------------------------------------------------*/
void rfIdDisable(void)
{
usart0RxIntDisable();
1376: 0e 94 3b 0b call 0x1676 ; 0x1676 <usart0RxIntDisable>
PORT_RFID |= (1<<RFID_ENABLE);
137a: 95 9a sbi 0x12, 5 ; 18
137c: 08 95 ret
0000137e <rfIdEnable>:
Input: -
Return: -
------------------------------------------------------------------------------------------------*/
void rfIdEnable(void)
{
PORT_RFID &= ~(1<<RFID_ENABLE);
137e: 95 98 cbi 0x12, 5 ; 18
usart0RxIntEnable();
1380: 0e 94 39 0b call 0x1672 ; 0x1672 <usart0RxIntEnable>
1384: 08 95 ret
00001386 <roboMSPGetActiveStatus>:
uint8_t firstDigit = 0;
uint8_t secondDigit = 0;
uint8_t thirdDigit = 0;
uint8_t fourthDigit = 0;
uint8_t fifthDigit = 0;
1386: 80 91 0e 04 lds r24, 0x040E
firstDigit = (hexValue/10000);
138a: 10 92 0e 04 sts 0x040E, r1
secondDigit = ((hexValue-(firstDigit*10000))/1000);
thirdDigit = ((hexValue-(firstDigit*10000+(secondDigit*1000)))/100);
138e: 99 27 eor r25, r25
1390: 08 95 ret
00001392 <calculateChecksum>:
if(firstDigit)
{
tempString[n] = (0x30|firstDigit);
n++;
}
1392: bc 01 movw r22, r24
1394: 40 e0 ldi r20, 0x00 ; 0
1396: 50 e0 ldi r21, 0x00 ; 0
1398: 20 e0 ldi r18, 0x00 ; 0
139a: 30 e0 ldi r19, 0x00 ; 0
if(secondDigit||firstDigit)
{
tempString[n] = (0x30|secondDigit);
n++;
}
if(thirdDigit||secondDigit||firstDigit)
139c: fb 01 movw r30, r22
139e: e2 0f add r30, r18
13a0: f3 1f adc r31, r19
13a2: 80 81 ld r24, Z
13a4: 48 0f add r20, r24
13a6: 51 1d adc r21, r1
13a8: 2f 5f subi r18, 0xFF ; 255
13aa: 3f 4f sbci r19, 0xFF ; 255
n++;
}
if(secondDigit||firstDigit)
{
tempString[n] = (0x30|secondDigit);
n++;
13ac: 2c 30 cpi r18, 0x0C ; 12
13ae: 31 05 cpc r19, r1
13b0: a9 f7 brne .-22 ; 0x139c <calculateChecksum+0xa>
{
tempString[n] = (0x30|thirdDigit);
n++;
}
if(fourthDigit||thirdDigit||secondDigit||firstDigit)
{
13b2: 84 2f mov r24, r20
13b4: 99 27 eor r25, r25
13b6: 08 95 ret
000013b8 <roboMSPValidatePacket>:
Input: data - char to correct
Return: corrected char
------------------------------------------------------------------------------------------------*/
uint8_t lcdEngToSwe (uint8_t data)
{
13b8: 1f 93 push r17
13ba: 10 91 62 04 lds r17, 0x0462
13be: 86 e5 ldi r24, 0x56 ; 86
13c0: 94 e0 ldi r25, 0x04 ; 4
13c2: 0e 94 c9 09 call 0x1392 ; 0x1392 <calculateChecksum>
13c6: 18 17 cp r17, r24
13c8: 51 f5 brne .+84 ; 0x141e <roboMSPValidatePacket+0x66>
switch(data)
{
13ca: 80 91 57 04 lds r24, 0x0457
13ce: 99 27 eor r25, r25
13d0: 8f 70 andi r24, 0x0F ; 15
13d2: 90 70 andi r25, 0x00 ; 0
13d4: 89 2b or r24, r25
13d6: 19 f5 brne .+70 ; 0x141e <roboMSPValidatePacket+0x66>
case '<27>':
data=0x99;
13d8: 80 91 58 04 lds r24, 0x0458
13dc: 82 34 cpi r24, 0x42 ; 66
13de: b1 f0 breq .+44 ; 0x140c <roboMSPValidatePacket+0x54>
13e0: 83 34 cpi r24, 0x43 ; 67
13e2: 28 f4 brcc .+10 ; 0x13ee <roboMSPValidatePacket+0x36>
13e4: 80 32 cpi r24, 0x20 ; 32
13e6: 61 f0 breq .+24 ; 0x1400 <roboMSPValidatePacket+0x48>
13e8: 81 34 cpi r24, 0x41 ; 65
13ea: c9 f4 brne .+50 ; 0x141e <roboMSPValidatePacket+0x66>
13ec: 0c c0 rjmp .+24 ; 0x1406 <roboMSPValidatePacket+0x4e>
13ee: 84 34 cpi r24, 0x44 ; 68
13f0: 99 f0 breq .+38 ; 0x1418 <roboMSPValidatePacket+0x60>
13f2: 84 34 cpi r24, 0x44 ; 68
13f4: 70 f0 brcs .+28 ; 0x1412 <roboMSPValidatePacket+0x5a>
13f6: 8a 3f cpi r24, 0xFA ; 250
13f8: 91 f4 brne .+36 ; 0x141e <roboMSPValidatePacket+0x66>
13fa: 85 e0 ldi r24, 0x05 ; 5
13fc: 90 e0 ldi r25, 0x00 ; 0
13fe: 11 c0 rjmp .+34 ; 0x1422 <roboMSPValidatePacket+0x6a>
1400: 81 e0 ldi r24, 0x01 ; 1
1402: 90 e0 ldi r25, 0x00 ; 0
1404: 0e c0 rjmp .+28 ; 0x1422 <roboMSPValidatePacket+0x6a>
break;
case '<27>':
data=0x94;
1406: 82 e0 ldi r24, 0x02 ; 2
1408: 90 e0 ldi r25, 0x00 ; 0
140a: 0b c0 rjmp .+22 ; 0x1422 <roboMSPValidatePacket+0x6a>
break;
case '<27>':
140c: 83 e0 ldi r24, 0x03 ; 3
140e: 90 e0 ldi r25, 0x00 ; 0
1410: 08 c0 rjmp .+16 ; 0x1422 <roboMSPValidatePacket+0x6a>
data=0x8E;
break;
1412: 84 e0 ldi r24, 0x04 ; 4
1414: 90 e0 ldi r25, 0x00 ; 0
1416: 05 c0 rjmp .+10 ; 0x1422 <roboMSPValidatePacket+0x6a>
case '<27>':
data=0x84;
1418: 86 e0 ldi r24, 0x06 ; 6
141a: 90 e0 ldi r25, 0x00 ; 0
141c: 02 c0 rjmp .+4 ; 0x1422 <roboMSPValidatePacket+0x6a>
break;
case '<27>':
141e: 80 e0 ldi r24, 0x00 ; 0
1420: 90 e0 ldi r25, 0x00 ; 0
1422: 1f 91 pop r17
1424: 08 95 ret
00001426 <roboMSPSetData>:
Input: cIntensity
Return: -
------------------------------------------------------------------------------------------------*/
void lcdSetIntensity (uint8_t intensity)
{
1426: dc 01 movw r26, r24
1428: e1 e1 ldi r30, 0x11 ; 17
142a: f4 e0 ldi r31, 0x04 ; 4
OCR0 = intensity;
}
/*------------------------------------------------------------------------------------------------
lcdWriteChar
142c: 8d 91 ld r24, X+
142e: 81 93 st Z+, r24
void lcdSetIntensity (uint8_t intensity)
{
OCR0 = intensity;
}
1430: 84 e0 ldi r24, 0x04 ; 4
1432: eb 31 cpi r30, 0x1B ; 27
1434: f8 07 cpc r31, r24
1436: d1 f7 brne .-12 ; 0x142c <roboMSPSetData+0x6>
/*------------------------------------------------------------------------------------------------
lcdWriteChar
Description: Writes character data to LCD.
1438: cf 01 movw r24, r30
143a: 0c 97 sbiw r24, 0x0c ; 12
143c: 0e 94 c9 09 call 0x1392 ; 0x1392 <calculateChecksum>
1440: 80 93 1b 04 sts 0x041B, r24
Input: cData
Return: -
1444: 81 e0 ldi r24, 0x01 ; 1
1446: 80 93 54 04 sts 0x0454, r24
144a: 08 95 ret
0000144c <roboMSPGetCommand>:
spiSelectDeviceIO(LCD_CS);
LCD_PORT |= (1<<LCD_RS);
spiWrite(lcdEngToSwe(data));
//_delay_us(20);
//_delay_us(20);
144c: 80 91 53 04 lds r24, 0x0453
}
1450: 99 27 eor r25, r25
1452: 08 95 ret
00001454 <roboMSPClearBuffer>:
Input: cData
Return: -
------------------------------------------------------------------------------------------------*/
void lcdWriteIns (uint8_t data)
{
1454: 10 92 52 04 sts 0x0452, r1
spiSetLowSpeed();
1458: 81 e0 ldi r24, 0x01 ; 1
145a: 80 93 55 04 sts 0x0455, r24
145e: 08 95 ret
00001460 <roboMSPInit>:
Input: *stringPointer (int[])
Return: -
------------------------------------------------------------------------------------------------*/
void lcdWriteStringP (const uint8_t *progmemStringPointer)
{
1460: 0e 94 7d 0b call 0x16fa ; 0x16fa <usart1Init>
1464: 80 e8 ldi r24, 0x80 ; 128
1466: 95 e2 ldi r25, 0x25 ; 37
1468: 0e 94 4c 0b call 0x1698 ; 0x1698 <usart1SetBaud>
register uint8_t c;
146c: 8c 9a sbi 0x11, 4 ; 17
while((c = pgm_read_byte(progmemStringPointer++)))
146e: 10 92 52 04 sts 0x0452, r1
{
1472: 81 e0 ldi r24, 0x01 ; 1
1474: 80 93 55 04 sts 0x0455, r24
lcdWriteChar(c);
1478: 10 92 54 04 sts 0x0454, r1
}
147c: 84 e0 ldi r24, 0x04 ; 4
147e: 80 93 0e 04 sts 0x040E, r24
1482: 08 95 ret
00001484 <roboMSPDisable>:
register uint8_t c;
while((c = *stringPointer++))
{
lcdWriteChar(c);
1484: 0e 94 79 0b call 0x16f2 ; 0x16f2 <usart1RxIntDisable>
1488: 08 95 ret
0000148a <roboMSPEnable>:
}
/*------------------------------------------------------------------------------------------------
lcdWriteString
Description: Writes a string of characters to LCD.
148a: 0e 94 75 0b call 0x16ea ; 0x16ea <usart1RxIntEnable>
148e: 08 95 ret
00001490 <roboMSPSendData>:
n++;
while(n<5)
{
tempString[n] = ' ';
n++;
1490: cf 93 push r28
1492: df 93 push r29
}
tempString[n] = '\0';
1494: 94 9a sbi 0x12, 4 ; 18
1496: 80 e4 ldi r24, 0x40 ; 64
1498: 9c e9 ldi r25, 0x9C ; 156
149a: fc 01 movw r30, r24
149c: 31 97 sbiw r30, 0x01 ; 1
149e: f1 f7 brne .-4 ; 0x149c <roboMSPSendData+0xc>
14a0: fc 01 movw r30, r24
14a2: 31 97 sbiw r30, 0x01 ; 1
14a4: f1 f7 brne .-4 ; 0x14a2 <roboMSPSendData+0x12>
14a6: fc 01 movw r30, r24
14a8: 31 97 sbiw r30, 0x01 ; 1
14aa: f1 f7 brne .-4 ; 0x14a8 <roboMSPSendData+0x18>
14ac: 01 97 sbiw r24, 0x01 ; 1
14ae: f1 f7 brne .-4 ; 0x14ac <roboMSPSendData+0x1c>
lcdWriteHex
Description: Writes hex to LCD
Input: hexValue
Output: -
----------------------------------------------------------------------------------------------------------*/
14b0: 80 e0 ldi r24, 0x00 ; 0
14b2: 0e 94 71 0b call 0x16e2 ; 0x16e2 <usart1Send>
void lcdWriteHex(uint16_t hexValue)
14b6: 80 e0 ldi r24, 0x00 ; 0
14b8: 0e 94 71 0b call 0x16e2 ; 0x16e2 <usart1Send>
{
14bc: 80 e0 ldi r24, 0x00 ; 0
14be: 0e 94 71 0b call 0x16e2 ; 0x16e2 <usart1Send>
uint8_t tempString[7];
uint8_t n=0;
14c2: 80 91 54 04 lds r24, 0x0454
14c6: 88 23 and r24, r24
14c8: 51 f0 breq .+20 ; 0x14de <roboMSPSendData+0x4e>
14ca: cf e0 ldi r28, 0x0F ; 15
14cc: d4 e0 ldi r29, 0x04 ; 4
uint8_t i;
tempString[n] = '0';
n++;
tempString[n] = 'x';
14ce: 89 91 ld r24, Y+
14d0: 0e 94 71 0b call 0x16e2 ; 0x16e2 <usart1Send>
uint8_t tempString[7];
uint8_t n=0;
uint8_t i;
tempString[n] = '0';
14d4: 84 e0 ldi r24, 0x04 ; 4
14d6: cc 31 cpi r28, 0x1C ; 28
14d8: d8 07 cpc r29, r24
14da: 51 f0 breq .+20 ; 0x14f0 <roboMSPSendData+0x60>
14dc: f8 cf rjmp .-16 ; 0x14ce <roboMSPSendData+0x3e>
14de: cc e1 ldi r28, 0x1C ; 28
14e0: d4 e0 ldi r29, 0x04 ; 4
for(i=0;i<4;i++)
{
if(((hexValue>>(12-(i*4)))&0x000F)>0x0009)
{
tempString[n] = (((hexValue>>(12-(i*4)))&0x000F)+0x37);
14e2: 89 91 ld r24, Y+
14e4: 0e 94 71 0b call 0x16e2 ; 0x16e2 <usart1Send>
n++;
for(i=0;i<4;i++)
{
if(((hexValue>>(12-(i*4)))&0x000F)>0x0009)
14e8: 84 e0 ldi r24, 0x04 ; 4
14ea: c9 32 cpi r28, 0x29 ; 41
14ec: d8 07 cpc r29, r24
14ee: c9 f7 brne .-14 ; 0x14e2 <roboMSPSendData+0x52>
tempString[n] = (((hexValue>>(12-(i*4)))&0x000F)+0x37);
n++;
}
else
{
tempString[n] = (((hexValue>>(12-(i*4)))&0x000F)|0x30);
14f0: 80 e0 ldi r24, 0x00 ; 0
14f2: 0e 94 71 0b call 0x16e2 ; 0x16e2 <usart1Send>
n++;
14f6: 80 e0 ldi r24, 0x00 ; 0
14f8: 0e 94 71 0b call 0x16e2 ; 0x16e2 <usart1Send>
}
14fc: 80 e0 ldi r24, 0x00 ; 0
14fe: 0e 94 71 0b call 0x16e2 ; 0x16e2 <usart1Send>
}
1502: 94 98 cbi 0x12, 4 ; 18
1504: 80 e8 ldi r24, 0x80 ; 128
1506: 9e e3 ldi r25, 0x3E ; 62
1508: 01 97 sbiw r24, 0x01 ; 1
150a: f1 f7 brne .-4 ; 0x1508 <roboMSPSendData+0x78>
150c: df 91 pop r29
150e: cf 91 pop r28
1510: 08 95 ret
00001512 <__vector_20>:
------------------------------------------------------------------------------------------------*/
void lcdSetDisplay (uint8_t value)
{
switch (value)
{
1512: 1f 92 push r1
1514: 0f 92 push r0
1516: 0f b6 in r0, 0x3f ; 63
1518: 0f 92 push r0
151a: 11 24 eor r1, r1
151c: 2f 93 push r18
151e: 3f 93 push r19
1520: 4f 93 push r20
1522: 5f 93 push r21
1524: 6f 93 push r22
1526: 7f 93 push r23
1528: 8f 93 push r24
152a: 9f 93 push r25
152c: af 93 push r26
152e: bf 93 push r27
1530: ef 93 push r30
1532: ff 93 push r31
case ON:
1534: 0e 94 6c 0b call 0x16d8 ; 0x16d8 <usart1Receive>
lcdTempReg |= 0x04;
break;
1538: 90 91 52 04 lds r25, 0x0452
153c: 99 23 and r25, r25
153e: 41 f4 brne .+16 ; 0x1550 <__vector_20+0x3e>
case OFF:
lcdTempReg &= ~(0x04);
1540: 8a 30 cpi r24, 0x0A ; 10
1542: 81 f4 brne .+32 ; 0x1564 <__vector_20+0x52>
break;
}
1544: 80 93 56 04 sts 0x0456, r24
1548: 81 e0 ldi r24, 0x01 ; 1
154a: 80 93 52 04 sts 0x0452, r24
154e: 0a c0 rjmp .+20 ; 0x1564 <__vector_20+0x52>
lcdWriteIns(0x08|lcdTempReg);
}
1550: 9d 30 cpi r25, 0x0D ; 13
1552: 40 f4 brcc .+16 ; 0x1564 <__vector_20+0x52>
/*------------------------------------------------------------------------------------------------
lcdSetCursor
1554: e9 2f mov r30, r25
1556: ff 27 eor r31, r31
1558: ea 5a subi r30, 0xAA ; 170
155a: fb 4f sbci r31, 0xFB ; 251
155c: 80 83 st Z, r24
155e: 9f 5f subi r25, 0xFF ; 255
1560: 90 93 52 04 sts 0x0452, r25
Description: Switch cursor on/off on LCD. Value: ON or OFF
1564: 80 91 52 04 lds r24, 0x0452
1568: 8d 30 cpi r24, 0x0D ; 13
156a: 41 f5 brne .+80 ; 0x15bc <__vector_20+0xaa>
Input: value
Return: -
156c: 0e 94 42 0a call 0x1484 ; 0x1484 <roboMSPDisable>
------------------------------------------------------------------------------------------------*/
1570: 78 94 sei
void lcdSetCursor (uint8_t value)
{
1572: 0e 94 dc 09 call 0x13b8 ; 0x13b8 <roboMSPValidatePacket>
1576: 80 93 53 04 sts 0x0453, r24
switch (value)
157a: 83 30 cpi r24, 0x03 ; 3
157c: a1 f0 breq .+40 ; 0x15a6 <__vector_20+0x94>
157e: 84 30 cpi r24, 0x04 ; 4
1580: 28 f4 brcc .+10 ; 0x158c <__vector_20+0x7a>
1582: 81 30 cpi r24, 0x01 ; 1
1584: 51 f0 breq .+20 ; 0x159a <__vector_20+0x88>
1586: 82 30 cpi r24, 0x02 ; 2
1588: a9 f4 brne .+42 ; 0x15b4 <__vector_20+0xa2>
158a: 0d c0 rjmp .+26 ; 0x15a6 <__vector_20+0x94>
158c: 85 30 cpi r24, 0x05 ; 5
158e: 71 f0 breq .+28 ; 0x15ac <__vector_20+0x9a>
1590: 85 30 cpi r24, 0x05 ; 5
1592: 40 f0 brcs .+16 ; 0x15a4 <__vector_20+0x92>
1594: 86 30 cpi r24, 0x06 ; 6
1596: 71 f4 brne .+28 ; 0x15b4 <__vector_20+0xa2>
1598: 06 c0 rjmp .+12 ; 0x15a6 <__vector_20+0x94>
{
case ON:
lcdTempReg |= 0x02;
159a: 80 93 0e 04 sts 0x040E, r24
break;
159e: 0e 94 48 0a call 0x1490 ; 0x1490 <roboMSPSendData>
15a2: 08 c0 rjmp .+16 ; 0x15b4 <__vector_20+0xa2>
}
/*------------------------------------------------------------------------------------------------
lcdSetBlink
Description: Switch blink on/off on LCD. Value: ON or OFF
15a4: 84 e0 ldi r24, 0x04 ; 4
Input: value
Return: -
------------------------------------------------------------------------------------------------*/
15a6: 80 93 0e 04 sts 0x040E, r24
15aa: 04 c0 rjmp .+8 ; 0x15b4 <__vector_20+0xa2>
void lcdSetBlink (uint8_t value)
{
switch (value)
15ac: 80 93 0e 04 sts 0x040E, r24
{
15b0: 10 92 54 04 sts 0x0454, r1
case ON:
lcdTempReg |= 0x01;
break;
case OFF:
15b4: 10 92 52 04 sts 0x0452, r1
lcdTempReg &= ~(0x01);
15b8: 0e 94 45 0a call 0x148a ; 0x148a <roboMSPEnable>
15bc: ff 91 pop r31
15be: ef 91 pop r30
15c0: bf 91 pop r27
15c2: af 91 pop r26
15c4: 9f 91 pop r25
15c6: 8f 91 pop r24
15c8: 7f 91 pop r23
15ca: 6f 91 pop r22
15cc: 5f 91 pop r21
15ce: 4f 91 pop r20
15d0: 3f 91 pop r19
15d2: 2f 91 pop r18
15d4: 0f 90 pop r0
15d6: 0f be out 0x3f, r0 ; 63
15d8: 0f 90 pop r0
15da: 1f 90 pop r1
15dc: 18 95 reti
000015de <spiWrite>:
Input: sensorValue
Output: -
----------------------------------------------------------------------------------------------------------*/
void lcdWriteHexAsDecimal(uint16_t hexValue)
{
uint8_t tempString[5]={" "};
15de: 8f b9 out 0x0f, r24 ; 15
uint8_t firstDigit = 0;
15e0: 77 9b sbis 0x0e, 7 ; 14
15e2: fe cf rjmp .-4 ; 0x15e0 <spiWrite+0x2>
15e4: 08 95 ret
000015e6 <spiReadIO>:
secondDigit = ((hexValue-(firstDigit*10000))/1000);
thirdDigit = ((hexValue-(firstDigit*10000+(secondDigit*1000)))/100);
fourthDigit = ((hexValue-(firstDigit*10000+(secondDigit*1000)+(thirdDigit*100)))/10);
fifthDigit = (hexValue-(firstDigit*10000+(secondDigit*1000)+(thirdDigit*100)+(fourthDigit*10)));
uint8_t n = 0;
15e6: 8f b1 in r24, 0x0f ; 15
15e8: 99 27 eor r25, r25
15ea: 08 95 ret
000015ec <spiSetHighSpeed>:
if(secondDigit||firstDigit)
{
tempString[n] = (0x30|secondDigit);
n++;
}
if(thirdDigit||secondDigit||firstDigit)
15ec: 68 98 cbi 0x0d, 0 ; 13
{
15ee: 69 98 cbi 0x0d, 1 ; 13
15f0: 08 95 ret
000015f2 <spiSetLowSpeed>:
n++;
}
tempString[n] = (0x30|fifthDigit);
n++;
while(n<5)
15f2: 68 98 cbi 0x0d, 0 ; 13
{
15f4: 69 9a sbi 0x0d, 1 ; 13
15f6: 08 95 ret
000015f8 <spiSelectDeviceIO>:
}
/*----------------------------------------------------------------------------------------------------------
lcdWriteHex
Description: Writes hex to LCD
Input: hexValue
15f8: 21 e0 ldi r18, 0x01 ; 1
15fa: 30 e0 ldi r19, 0x00 ; 0
15fc: 02 c0 rjmp .+4 ; 0x1602 <spiSelectDeviceIO+0xa>
15fe: 22 0f add r18, r18
1600: 33 1f adc r19, r19
1602: 8a 95 dec r24
1604: e2 f7 brpl .-8 ; 0x15fe <spiSelectDeviceIO+0x6>
1606: 20 95 com r18
1608: 2b bb out 0x1b, r18 ; 27
160a: 08 95 ret
0000160c <spiInit>:
uint8_t i;
tempString[n] = '0';
n++;
tempString[n] = 'x';
n++;
160c: 87 b3 in r24, 0x17 ; 23
160e: 80 6b ori r24, 0xB0 ; 176
1610: 87 bb out 0x17, r24 ; 23
1612: c6 9a sbi 0x18, 6 ; 24
for(i=0;i<4;i++)
{
1614: d0 9a sbi 0x1a, 0 ; 26
1616: d8 9a sbi 0x1b, 0 ; 27
if(((hexValue>>(12-(i*4)))&0x000F)>0x0009)
{
1618: 8d b1 in r24, 0x0d ; 13
161a: 81 65 ori r24, 0x51 ; 81
161c: 8d b9 out 0x0d, r24 ; 13
161e: 08 95 ret
00001620 <usart0SetBaud>:
================================================================================================*/
/*----------------------------------------------------------------------------------------------------------
lcdWriteHexAsDecimal
Description: Writes hex value as decimal to LCD
Input: sensorValue
1620: 9c 01 movw r18, r24
1622: 94 e0 ldi r25, 0x04 ; 4
1624: 22 0f add r18, r18
1626: 33 1f adc r19, r19
1628: 9a 95 dec r25
162a: e1 f7 brne .-8 ; 0x1624 <usart0SetBaud+0x4>
162c: 44 27 eor r20, r20
162e: 55 27 eor r21, r21
1630: 60 e0 ldi r22, 0x00 ; 0
1632: 74 e2 ldi r23, 0x24 ; 36
1634: 84 ef ldi r24, 0xF4 ; 244
1636: 90 e0 ldi r25, 0x00 ; 0
1638: 0e 94 09 0c call 0x1812 ; 0x1812 <__divmodsi4>
163c: 21 50 subi r18, 0x01 ; 1
163e: 30 40 sbci r19, 0x00 ; 0
1640: 40 40 sbci r20, 0x00 ; 0
1642: 50 40 sbci r21, 0x00 ; 0
1644: bb 27 eor r27, r27
1646: 57 fd sbrc r21, 7
1648: ba 95 dec r27
164a: a5 2f mov r26, r21
164c: 94 2f mov r25, r20
164e: 83 2f mov r24, r19
1650: 2f 5f subi r18, 0xFF ; 255
1652: 3f 4f sbci r19, 0xFF ; 255
1654: 4f 4f sbci r20, 0xFF ; 255
1656: 5f 4f sbci r21, 0xFF ; 255
1658: 80 bd out 0x20, r24 ; 32
Output: -
165a: 21 50 subi r18, 0x01 ; 1
165c: 29 b9 out 0x09, r18 ; 9
165e: 08 95 ret
00001660 <usart0Receive>:
uint8_t fourthDigit = 0;
uint8_t fifthDigit = 0;
firstDigit = (hexValue/10000);
secondDigit = ((hexValue-(firstDigit*10000))/1000);
thirdDigit = ((hexValue-(firstDigit*10000+(secondDigit*1000)))/100);
1660: 5f 9b sbis 0x0b, 7 ; 11
1662: fe cf rjmp .-4 ; 0x1660 <usart0Receive>
fourthDigit = ((hexValue-(firstDigit*10000+(secondDigit*1000)+(thirdDigit*100)))/10);
fifthDigit = (hexValue-(firstDigit*10000+(secondDigit*1000)+(thirdDigit*100)+(fourthDigit*10)));
1664: 8c b1 in r24, 0x0c ; 12
1666: 99 27 eor r25, r25
1668: 08 95 ret
0000166a <usart0Send>:
}
if(secondDigit||firstDigit)
{
tempString[n] = (0x30|secondDigit);
n++;
}
166a: 5d 9b sbis 0x0b, 5 ; 11
166c: fe cf rjmp .-4 ; 0x166a <usart0Send>
if(thirdDigit||secondDigit||firstDigit)
{
166e: 8c b9 out 0x0c, r24 ; 12
1670: 08 95 ret
00001672 <usart0RxIntEnable>:
Input: hexValue
Output: -
----------------------------------------------------------------------------------------------------------*/
void lcdWriteHex(uint16_t hexValue)
{
uint8_t tempString[7];
1672: 57 9a sbi 0x0a, 7 ; 10
1674: 08 95 ret
00001676 <usart0RxIntDisable>:
n++;
for(i=0;i<4;i++)
{
if(((hexValue>>(12-(i*4)))&0x000F)>0x0009)
1676: 57 98 cbi 0x0a, 7 ; 10
1678: 08 95 ret
0000167a <usart0Init>:
}
}
tempString[n] = '\0';
lcdWriteString(tempString);
167a: 89 9a sbi 0x11, 1 ; 17
}
167c: 8a b1 in r24, 0x0a ; 10
167e: 88 69 ori r24, 0x98 ; 152
1680: 8a b9 out 0x0a, r24 ; 10
1682: 08 95 ret
00001684 <usart0SendString>:
tempString[n] = (0x30|fourthDigit);
n++;
}
tempString[n] = (0x30|fifthDigit);
n++;
1684: fc 01 movw r30, r24
1686: 04 c0 rjmp .+8 ; 0x1690 <usart0SendString+0xc>
}
if(secondDigit||firstDigit)
{
tempString[n] = (0x30|secondDigit);
n++;
}
1688: 5d 9b sbis 0x0b, 5 ; 11
168a: fe cf rjmp .-4 ; 0x1688 <usart0SendString+0x4>
if(thirdDigit||secondDigit||firstDigit)
{
168c: 8c b9 out 0x0c, r24 ; 12
while(n<5)
{
tempString[n] = ' ';
n++;
}
168e: 31 96 adiw r30, 0x01 ; 1
}
tempString[n] = (0x30|fifthDigit);
n++;
while(n<5)
{
1690: 80 81 ld r24, Z
1692: 88 23 and r24, r24
1694: c9 f7 brne .-14 ; 0x1688 <usart0SendString+0x4>
1696: 08 95 ret
00001698 <usart1SetBaud>:
static uint8_t lcdTempReg;
/*================================================================================================
Functions
================================================================================================*/
/*----------------------------------------------------------------------------------------------------------
lcdWriteHexAsDecimal
1698: 9c 01 movw r18, r24
169a: 94 e0 ldi r25, 0x04 ; 4
169c: 22 0f add r18, r18
169e: 33 1f adc r19, r19
16a0: 9a 95 dec r25
16a2: e1 f7 brne .-8 ; 0x169c <usart1SetBaud+0x4>
16a4: 44 27 eor r20, r20
16a6: 55 27 eor r21, r21
16a8: 60 e0 ldi r22, 0x00 ; 0
16aa: 74 e2 ldi r23, 0x24 ; 36
16ac: 84 ef ldi r24, 0xF4 ; 244
16ae: 90 e0 ldi r25, 0x00 ; 0
16b0: 0e 94 09 0c call 0x1812 ; 0x1812 <__divmodsi4>
16b4: 21 50 subi r18, 0x01 ; 1
16b6: 30 40 sbci r19, 0x00 ; 0
16b8: 40 40 sbci r20, 0x00 ; 0
16ba: 50 40 sbci r21, 0x00 ; 0
16bc: bb 27 eor r27, r27
16be: 57 fd sbrc r21, 7
16c0: ba 95 dec r27
16c2: a5 2f mov r26, r21
16c4: 94 2f mov r25, r20
16c6: 83 2f mov r24, r19
16c8: 2f 5f subi r18, 0xFF ; 255
16ca: 3f 4f sbci r19, 0xFF ; 255
16cc: 4f 4f sbci r20, 0xFF ; 255
16ce: 5f 4f sbci r21, 0xFF ; 255
16d0: 8c bf out 0x3c, r24 ; 60
16d2: 21 50 subi r18, 0x01 ; 1
16d4: 20 b9 out 0x00, r18 ; 0
16d6: 08 95 ret
000016d8 <usart1Receive>:
uint8_t firstDigit = 0;
uint8_t secondDigit = 0;
uint8_t thirdDigit = 0;
uint8_t fourthDigit = 0;
uint8_t fifthDigit = 0;
16d8: 17 9b sbis 0x02, 7 ; 2
16da: fe cf rjmp .-4 ; 0x16d8 <usart1Receive>
firstDigit = (hexValue/10000);
secondDigit = ((hexValue-(firstDigit*10000))/1000);
16dc: 83 b1 in r24, 0x03 ; 3
thirdDigit = ((hexValue-(firstDigit*10000+(secondDigit*1000)))/100);
16de: 99 27 eor r25, r25
16e0: 08 95 ret
000016e2 <usart1Send>:
{
tempString[n] = (0x30|firstDigit);
n++;
}
if(secondDigit||firstDigit)
{
16e2: 15 9b sbis 0x02, 5 ; 2
16e4: fe cf rjmp .-4 ; 0x16e2 <usart1Send>
tempString[n] = (0x30|secondDigit);
n++;
16e6: 83 b9 out 0x03, r24 ; 3
16e8: 08 95 ret
000016ea <usart1RxIntEnable>:
Description: Writes hex to LCD
Input: hexValue
Output: -
----------------------------------------------------------------------------------------------------------*/
void lcdWriteHex(uint16_t hexValue)
16ea: 81 b1 in r24, 0x01 ; 1
16ec: 80 69 ori r24, 0x90 ; 144
16ee: 81 b9 out 0x01, r24 ; 1
16f0: 08 95 ret
000016f2 <usart1RxIntDisable>:
n++;
tempString[n] = 'x';
n++;
for(i=0;i<4;i++)
{
16f2: 81 b1 in r24, 0x01 ; 1
16f4: 8f 76 andi r24, 0x6F ; 111
16f6: 81 b9 out 0x01, r24 ; 1
16f8: 08 95 ret
000016fa <usart1Init>:
tempString[n] = (((hexValue>>(12-(i*4)))&0x000F)|0x30);
n++;
}
}
tempString[n] = '\0';
16fa: bb 9a sbi 0x17, 3 ; 23
16fc: 81 b1 in r24, 0x01 ; 1
16fe: 88 69 ori r24, 0x98 ; 152
1700: 81 b9 out 0x01, r24 ; 1
1702: 08 95 ret
00001704 <usart1SendString>:
}
if(fourthDigit||thirdDigit||secondDigit||firstDigit)
{
tempString[n] = (0x30|fourthDigit);
n++;
}
1704: fc 01 movw r30, r24
1706: 04 c0 rjmp .+8 ; 0x1710 <usart1SendString+0xc>
{
tempString[n] = (0x30|firstDigit);
n++;
}
if(secondDigit||firstDigit)
{
1708: 15 9b sbis 0x02, 5 ; 2
170a: fe cf rjmp .-4 ; 0x1708 <usart1SendString+0x4>
tempString[n] = (0x30|secondDigit);
n++;
170c: 83 b9 out 0x03, r24 ; 3
}
tempString[n] = (0x30|fifthDigit);
n++;
while(n<5)
{
170e: 31 96 adiw r30, 0x01 ; 1
{
tempString[n] = (0x30|fourthDigit);
n++;
}
tempString[n] = (0x30|fifthDigit);
n++;
1710: 80 81 ld r24, Z
1712: 88 23 and r24, r24
1714: c9 f7 brne .-14 ; 0x1708 <usart1SendString+0x4>
1716: 08 95 ret
00001718 <pingSendPing>:
Description: Gets pointer current TAG id
Input: -
Return: pointer to rfIdTagBuffer
------------------------------------------------------------------------------------------------*/
1718: f8 94 cli
uint8_t* rfIdGetTag( void )
{
171a: 80 91 64 04 lds r24, 0x0464
171e: 88 23 and r24, r24
1720: 69 f4 brne .+26 ; 0x173c <pingSendPing+0x24>
rfIdGotTag = 0;
//PORT_RFID |= (1<<RFID_ENABLE);
return rfIdTagBuffer;
1722: 8a 9a sbi 0x11, 2 ; 17
}
1724: 92 9a sbi 0x12, 2 ; 18
1726: 8a e0 ldi r24, 0x0A ; 10
1728: 8a 95 dec r24
172a: f1 f7 brne .-4 ; 0x1728 <pingSendPing+0x10>
/*------------------------------------------------------------------------------------------------
rfIDClearBuffer
Description: Clearing current TAG-buffer
172c: 92 98 cbi 0x12, 2 ; 18
172e: 8a 98 cbi 0x11, 2 ; 17
Input: -
Return: -
1730: 85 b7 in r24, 0x35 ; 53
1732: 83 60 ori r24, 0x03 ; 3
1734: 85 bf out 0x35, r24 ; 53
------------------------------------------------------------------------------------------------*/
1736: 8b b7 in r24, 0x3b ; 59
1738: 80 64 ori r24, 0x40 ; 64
173a: 8b bf out 0x3b, r24 ; 59
void rfIdClearBuffer( void )
{
rfIdByteCount = 0;
173c: 78 94 sei
173e: 08 95 ret
00001740 <pingGetDistance>:
Description: Returns if a TAG has been transfered to the TAG-buffer
Input: -
Return: 1 if true, else 0
------------------------------------------------------------------------------------------------*/
uint8_t rfIdGetTagPresent( void )
1740: 10 92 64 04 sts 0x0464, r1
{
1744: 80 91 88 00 lds r24, 0x0088
1748: 90 91 89 00 lds r25, 0x0089
174c: 08 95 ret
0000174e <pingGetReady>:
Description: Enable incoming data
Input: -
Return: -
------------------------------------------------------------------------------------------------*/
174e: 80 91 64 04 lds r24, 0x0464
void rfIdEnable(void)
{
1752: 99 27 eor r25, r25
1754: 08 95 ret
00001756 <pingInit>:
/*------------------------------------------------------------------------------------------------
rfIdDisable
Description: Disable incoming data
Input: -
1756: 08 95 ret
00001758 <__vector_1>:
rfIdInit
Description: Initialize components
Input: -
Return: -
1758: 1f 92 push r1
175a: 0f 92 push r0
175c: 0f b6 in r0, 0x3f ; 63
175e: 0f 92 push r0
1760: 11 24 eor r1, r1
1762: 8f 93 push r24
------------------------------------------------------------------------------------------------*/
1764: 05 b6 in r0, 0x35 ; 53
1766: 00 fe sbrs r0, 0
1768: 0d c0 rjmp .+26 ; 0x1784 <__vector_1+0x2c>
void rfIdInit(void)
{
176a: 10 92 89 00 sts 0x0089, r1
usart0Init();
176e: 10 92 88 00 sts 0x0088, r1
usart0SetBaud(USART0_BAUD_RATE);
rfIdByteCount = 0;
1772: 85 b7 in r24, 0x35 ; 53
1774: 8e 7f andi r24, 0xFE ; 254
1776: 85 bf out 0x35, r24 ; 53
1778: 80 91 8a 00 lds r24, 0x008A
177c: 82 60 ori r24, 0x02 ; 2
177e: 80 93 8a 00 sts 0x008A, r24
1782: 0b c0 rjmp .+22 ; 0x179a <__vector_1+0x42>
DDR_RFID |= (1<<RFID_ENABLE);
PORT_RFID &= ~(1<<RFID_ENABLE);
}
/*================================================================================================
1784: 80 91 8a 00 lds r24, 0x008A
1788: 8d 7f andi r24, 0xFD ; 253
178a: 80 93 8a 00 sts 0x008A, r24
Interrupt
178e: 81 e0 ldi r24, 0x01 ; 1
1790: 80 93 64 04 sts 0x0464, r24
================================================================================================*/
1794: 8b b7 in r24, 0x3b ; 59
1796: 8f 7b andi r24, 0xBF ; 191
1798: 8b bf out 0x3b, r24 ; 59
179a: 8f 91 pop r24
179c: 0f 90 pop r0
179e: 0f be out 0x3f, r0 ; 63
17a0: 0f 90 pop r0
17a2: 1f 90 pop r1
17a4: 18 95 reti
000017a6 <__udivmodhi4>:
17a6: aa 1b sub r26, r26
17a8: bb 1b sub r27, r27
17aa: 51 e1 ldi r21, 0x11 ; 17
17ac: 07 c0 rjmp .+14 ; 0x17bc <__udivmodhi4_ep>
000017ae <__udivmodhi4_loop>:
17ae: aa 1f adc r26, r26
17b0: bb 1f adc r27, r27
17b2: a6 17 cp r26, r22
17b4: b7 07 cpc r27, r23
17b6: 10 f0 brcs .+4 ; 0x17bc <__udivmodhi4_ep>
17b8: a6 1b sub r26, r22
17ba: b7 0b sbc r27, r23
000017bc <__udivmodhi4_ep>:
17bc: 88 1f adc r24, r24
17be: 99 1f adc r25, r25
17c0: 5a 95 dec r21
17c2: a9 f7 brne .-22 ; 0x17ae <__udivmodhi4_loop>
17c4: 80 95 com r24
17c6: 90 95 com r25
17c8: bc 01 movw r22, r24
17ca: cd 01 movw r24, r26
17cc: 08 95 ret
000017ce <__udivmodsi4>:
17ce: a1 e2 ldi r26, 0x21 ; 33
17d0: 1a 2e mov r1, r26
17d2: aa 1b sub r26, r26
17d4: bb 1b sub r27, r27
17d6: fd 01 movw r30, r26
17d8: 0d c0 rjmp .+26 ; 0x17f4 <__udivmodsi4_ep>
000017da <__udivmodsi4_loop>:
17da: aa 1f adc r26, r26
17dc: bb 1f adc r27, r27
17de: ee 1f adc r30, r30
17e0: ff 1f adc r31, r31
17e2: a2 17 cp r26, r18
17e4: b3 07 cpc r27, r19
17e6: e4 07 cpc r30, r20
17e8: f5 07 cpc r31, r21
17ea: 20 f0 brcs .+8 ; 0x17f4 <__udivmodsi4_ep>
17ec: a2 1b sub r26, r18
17ee: b3 0b sbc r27, r19
17f0: e4 0b sbc r30, r20
17f2: f5 0b sbc r31, r21
000017f4 <__udivmodsi4_ep>:
17f4: 66 1f adc r22, r22
17f6: 77 1f adc r23, r23
17f8: 88 1f adc r24, r24
17fa: 99 1f adc r25, r25
17fc: 1a 94 dec r1
17fe: 69 f7 brne .-38 ; 0x17da <__udivmodsi4_loop>
1800: 60 95 com r22
1802: 70 95 com r23
1804: 80 95 com r24
1806: 90 95 com r25
1808: 9b 01 movw r18, r22
180a: ac 01 movw r20, r24
180c: bd 01 movw r22, r26
180e: cf 01 movw r24, r30
1810: 08 95 ret
00001812 <__divmodsi4>:
1812: 97 fb bst r25, 7
1814: 09 2e mov r0, r25
1816: 05 26 eor r0, r21
1818: 0e d0 rcall .+28 ; 0x1836 <__divmodsi4_neg1>
181a: 57 fd sbrc r21, 7
181c: 04 d0 rcall .+8 ; 0x1826 <__divmodsi4_neg2>
181e: d7 df rcall .-82 ; 0x17ce <__udivmodsi4>
1820: 0a d0 rcall .+20 ; 0x1836 <__divmodsi4_neg1>
1822: 00 1c adc r0, r0
1824: 38 f4 brcc .+14 ; 0x1834 <__divmodsi4_exit>
00001826 <__divmodsi4_neg2>:
1826: 50 95 com r21
1828: 40 95 com r20
182a: 30 95 com r19
182c: 21 95 neg r18
182e: 3f 4f sbci r19, 0xFF ; 255
1830: 4f 4f sbci r20, 0xFF ; 255
1832: 5f 4f sbci r21, 0xFF ; 255
00001834 <__divmodsi4_exit>:
1834: 08 95 ret
00001836 <__divmodsi4_neg1>:
1836: f6 f7 brtc .-4 ; 0x1834 <__divmodsi4_exit>
1838: 90 95 com r25
183a: 80 95 com r24
183c: 70 95 com r23
183e: 61 95 neg r22
1840: 7f 4f sbci r23, 0xFF ; 255
1842: 8f 4f sbci r24, 0xFF ; 255
1844: 9f 4f sbci r25, 0xFF ; 255
1846: 08 95 ret
00001848 <_exit>:
1848: ff cf rjmp .-2 ; 0x1848 <_exit>
Reference in New Issue View Git Blame Copy Permalink