📄 main.lss
字号:
SPDR = Byte; //Sendet ein Byte
278: 8f b9 out 0x0f, r24 ; 15
while(!(SPSR & (1<<SPIF))) //Wartet bis Byte gesendet wurde
27a: 77 9b sbis 0x0e, 7 ; 14
27c: fe cf rjmp .-4 ; 0x27a
27e: 08 95 ret
00000280 <mmc_read_byte>:
280: 8f ef ldi r24, 0xFF ; 255
282: 8f b9 out 0x0f, r24 ; 15
284: 77 9b sbis 0x0e, 7 ; 14
286: fe cf rjmp .-4 ; 0x284
288: 8f b1 in r24, 0x0f ; 15
28a: 99 27 eor r25, r25
28c: 08 95 ret
0000028e <mmc_write_command>:
28e: fc 01 movw r30, r24
290: 2f ef ldi r18, 0xFF ; 255
292: 40 e0 ldi r20, 0x00 ; 0
294: 50 e0 ldi r21, 0x00 ; 0
296: c3 9a sbi 0x18, 3 ; 24
298: 2f b9 out 0x0f, r18 ; 15
29a: 77 9b sbis 0x0e, 7 ; 14
29c: fe cf rjmp .-4 ; 0x29a
29e: c3 98 cbi 0x18, 3 ; 24
2a0: 90 e0 ldi r25, 0x00 ; 0
2a2: 81 91 ld r24, Z+
2a4: 8f b9 out 0x0f, r24 ; 15
2a6: 77 9b sbis 0x0e, 7 ; 14
2a8: fe cf rjmp .-4 ; 0x2a6
2aa: 9f 5f subi r25, 0xFF ; 255
2ac: 96 30 cpi r25, 0x06 ; 6
2ae: c8 f3 brcs .-14 ; 0x2a2
2b0: 3f ef ldi r19, 0xFF ; 255
2b2: 3f b9 out 0x0f, r19 ; 15
2b4: 77 9b sbis 0x0e, 7 ; 14
2b6: fe cf rjmp .-4 ; 0x2b4
2b8: 8f b1 in r24, 0x0f ; 15
2ba: 28 2f mov r18, r24
2bc: ca 01 movw r24, r20
2be: 4f 5f subi r20, 0xFF ; 255
2c0: 5f 4f sbci r21, 0xFF ; 255
2c2: 85 5f subi r24, 0xF5 ; 245
2c4: 91 40 sbci r25, 0x01 ; 1
2c6: 10 f4 brcc .+4 ; 0x2cc
2c8: 2f 3f cpi r18, 0xFF ; 255
2ca: 99 f3 breq .-26 ; 0x2b2
2cc: 82 2f mov r24, r18
2ce: 99 27 eor r25, r25
2d0: 08 95 ret
000002d2 <mmc_init>:
2d2: 1f 93 push r17
2d4: cf 93 push r28
2d6: df 93 push r29
2d8: cd b7 in r28, 0x3d ; 61
2da: de b7 in r29, 0x3e ; 62
2dc: 26 97 sbiw r28, 0x06 ; 6
2de: 0f b6 in r0, 0x3f ; 63
2e0: f8 94 cli
2e2: de bf out 0x3e, r29 ; 62
2e4: 0f be out 0x3f, r0 ; 63
2e6: cd bf out 0x3d, r28 ; 61
2e8: 10 e0 ldi r17, 0x00 ; 0
2ea: be 98 cbi 0x17, 6 ; 23
2ec: bf 9a sbi 0x17, 7 ; 23
2ee: bd 9a sbi 0x17, 5 ; 23
2f0: bb 9a sbi 0x17, 3 ; 23
2f2: bc 9a sbi 0x17, 4 ; 23
2f4: c3 9a sbi 0x18, 3 ; 24
2f6: 81 2f mov r24, r17
2f8: 00 00 nop
2fa: 8f 5f subi r24, 0xFF ; 255
2fc: 88 3c cpi r24, 0xC8 ; 200
2fe: e0 f3 brcs .-8 ; 0x2f8
300: 83 e5 ldi r24, 0x53 ; 83
302: 8d b9 out 0x0d, r24 ; 13
304: 1e b8 out 0x0e, r1 ; 14
306: 80 e0 ldi r24, 0x00 ; 0
308: 9f ef ldi r25, 0xFF ; 255
30a: 9f b9 out 0x0f, r25 ; 15
30c: 77 9b sbis 0x0e, 7 ; 14
30e: fe cf rjmp .-4 ; 0x30c
310: 8f 5f subi r24, 0xFF ; 255
312: 8f 30 cpi r24, 0x0F ; 15
314: d0 f3 brcs .-12 ; 0x30a
316: 86 e0 ldi r24, 0x06 ; 6
318: a0 e1 ldi r26, 0x10 ; 16
31a: b1 e0 ldi r27, 0x01 ; 1
31c: fe 01 movw r30, r28
31e: 31 96 adiw r30, 0x01 ; 1
320: 0d 90 ld r0, X+
322: 01 92 st Z+, r0
324: 8a 95 dec r24
326: e1 f7 brne .-8 ; 0x320
328: 07 c0 rjmp .+14 ; 0x338
32a: 81 2f mov r24, r17
32c: 1f 5f subi r17, 0xFF ; 255
32e: 89 3c cpi r24, 0xC9 ; 201
330: 18 f0 brcs .+6 ; 0x338
332: 81 e0 ldi r24, 0x01 ; 1
334: 90 e0 ldi r25, 0x00 ; 0
336: 20 c0 rjmp .+64 ; 0x378
338: ce 01 movw r24, r28
33a: 01 96 adiw r24, 0x01 ; 1
33c: 0e 94 47 01 call 0x28e
340: 81 30 cpi r24, 0x01 ; 1
342: 99 f7 brne .-26 ; 0x32a
344: 10 e0 ldi r17, 0x00 ; 0
346: 81 e4 ldi r24, 0x41 ; 65
348: 89 83 std Y+1, r24 ; 0x01
34a: 8f ef ldi r24, 0xFF ; 255
34c: 8e 83 std Y+6, r24 ; 0x06
34e: 07 c0 rjmp .+14 ; 0x35e
350: 81 2f mov r24, r17
352: 1f 5f subi r17, 0xFF ; 255
354: 85 36 cpi r24, 0x65 ; 101
356: 18 f0 brcs .+6 ; 0x35e
358: 82 e0 ldi r24, 0x02 ; 2
35a: 90 e0 ldi r25, 0x00 ; 0
35c: 0d c0 rjmp .+26 ; 0x378
35e: ce 01 movw r24, r28
360: 01 96 adiw r24, 0x01 ; 1
362: 0e 94 47 01 call 0x28e
366: 88 23 and r24, r24
368: 99 f7 brne .-26 ; 0x350
36a: 8d b1 in r24, 0x0d ; 13
36c: 8c 7f andi r24, 0xFC ; 252
36e: 8d b9 out 0x0d, r24 ; 13
370: 70 9a sbi 0x0e, 0 ; 14
372: c3 9a sbi 0x18, 3 ; 24
374: 80 e0 ldi r24, 0x00 ; 0
376: 90 e0 ldi r25, 0x00 ; 0
378: 26 96 adiw r28, 0x06 ; 6
37a: 0f b6 in r0, 0x3f ; 63
37c: f8 94 cli
37e: de bf out 0x3e, r29 ; 62
380: 0f be out 0x3f, r0 ; 63
382: cd bf out 0x3d, r28 ; 61
384: df 91 pop r29
386: cf 91 pop r28
388: 1f 91 pop r17
38a: 08 95 ret
0000038c <mmc_write_sector>:
{
}
#else //Routine f黵 Software SPI
for (U08 a=8; a>0; a--) //das Byte wird Bitweise nacheinander Gesendet MSB First
{
if (bit_is_set(Byte,(a-1))>0) //Ist Bit a in Byte gesetzt
{
MMC_Write |= (1<<SPI_DO); //Set Output High
}
else
{
MMC_Write &= ~(1<<SPI_DO); //Set Output Low
}
MMC_Write &= ~(1<<SPI_Clock); //erzeugt ein Clock Impuls (LOW)
MMC_Write |= (1<<SPI_Clock); //setzt Clock Impuls wieder auf (High)
}
MMC_Write |= (1<<SPI_DO); //setzt Output wieder auf High
#endif
}
//############################################################################
//Routine zum schreiben eines Blocks(512Byte) auf die MMC/SD-Karte
U08 mmc_write_sector (U32 addr,U08 *Buffer)
//############################################################################
{
38c: cf 92 push r12
38e: df 92 push r13
390: ef 92 push r14
392: ff 92 push r15
394: 0f 93 push r16
396: 1f 93 push r17
398: cf 93 push r28
39a: df 93 push r29
39c: cd b7 in r28, 0x3d ; 61
39e: de b7 in r29, 0x3e ; 62
3a0: 26 97 sbiw r28, 0x06 ; 6
3a2: 0f b6 in r0, 0x3f ; 63
3a4: f8 94 cli
3a6: de bf out 0x3e, r29 ; 62
3a8: 0f be out 0x3f, r0 ; 63
3aa: cd bf out 0x3d, r28 ; 61
3ac: 6b 01 movw r12, r22
3ae: 7c 01 movw r14, r24
3b0: 8a 01 movw r16, r20
U08 tmp;
//Commando 24 zum schreiben eines Blocks auf die MMC/SD - Karte
U08 cmd[] = {0x58,0x00,0x00,0x00,0x00,0xFF};
3b2: be 01 movw r22, r28
3b4: 6f 5f subi r22, 0xFF ; 255
3b6: 7f 4f sbci r23, 0xFF ; 255
3b8: 26 e0 ldi r18, 0x06 ; 6
3ba: 46 e1 ldi r20, 0x16 ; 22
3bc: 51 e0 ldi r21, 0x01 ; 1
3be: db 01 movw r26, r22
3c0: fa 01 movw r30, r20
3c2: 01 90 ld r0, Z+
3c4: 0d 92 st X+, r0
3c6: 2a 95 dec r18
3c8: e1 f7 brne .-8 ; 0x3c2
/*Die Adressierung der MMC/SD-Karte wird in Bytes angegeben,
addr wird von Blocks zu Bytes umgerechnet danach werden
diese in das Commando eingef黦t*/
addr = addr << 9; //addr = addr * 512
3ca: 29 e0 ldi r18, 0x09 ; 9
3cc: cc 0c add r12, r12
3ce: dd 1c adc r13, r13
3d0: ee 1c adc r14, r14
3d2: ff 1c adc r15, r15
3d4: 2a 95 dec r18
3d6: d1 f7 brne .-12 ; 0x3cc
cmd[1] = ((addr & 0xFF000000) >>24 );
3d8: 2f 2d mov r18, r15
3da: 33 27 eor r19, r19
3dc: 44 27 eor r20, r20
3de: 55 27 eor r21, r21
3e0: 2a 83 std Y+2, r18 ; 0x02
cmd[2] = ((addr & 0x00FF0000) >>16 );
3e2: eb 82 std Y+3, r14 ; 0x03
cmd[3] = ((addr & 0x0000FF00) >>8 );
3e4: 80 e0 ldi r24, 0x00 ; 0
3e6: 9f ef ldi r25, 0xFF ; 255
3e8: a0 e0 ldi r26, 0x00 ; 0
3ea: b0 e0 ldi r27, 0x00 ; 0
3ec: c8 22 and r12, r24
3ee: d9 22 and r13, r25
3f0: ea 22 and r14, r26
3f2: fb 22 and r15, r27
3f4: bb 27 eor r27, r27
3f6: af 2d mov r26, r15
3f8: 9e 2d mov r25, r14
3fa: 8d 2d mov r24, r13
3fc: 8c 83 std Y+4, r24 ; 0x04
//Sendet Commando cmd24 an MMC/SD-Karte (Write 1 Block/512 Bytes)
tmp = mmc_write_command (cmd);
3fe: cb 01 movw r24, r22
400: 0e 94 47 01 call 0x28e
if (tmp != 0)
404: 88 23 and r24, r24
406: 11 f0 breq .+4 ; 0x40c
{
return(tmp);
408: 99 27 eor r25, r25
40a: 2d c0 rjmp .+90 ; 0x466
}
//Wartet einen Moment und sendet einen Clock an die MMC/SD-Karte
for (U08 a=0;a<100;a++)
40c: 98 2f mov r25, r24
40e: 2f ef ldi r18, 0xFF ; 255
410: 2f b9 out 0x0f, r18 ; 15
412: 77 9b sbis 0x0e, 7 ; 14
414: fe cf rjmp .-4 ; 0x412
416: 8f b1 in r24, 0x0f ; 15
418: 9f 5f subi r25, 0xFF ; 255
41a: 94 36 cpi r25, 0x64 ; 100
41c: c8 f3 brcs .-14 ; 0x410
41e: 8e ef ldi r24, 0xFE ; 254
420: 8f b9 out 0x0f, r24 ; 15
422: 77 9b sbis 0x0e, 7 ; 14
424: fe cf rjmp .-4 ; 0x422
{
mmc_read_byte();
}
//Sendet Start Byte an MMC/SD-Karte
mmc_write_byte(0xFE);
//Schreiben des Bolcks (512Bytes) auf MMC/SD-Karte
for (U16 a=0;a<512;a++)
426: 20 e0 ldi r18, 0x00 ; 0
428: 30 e0 ldi r19, 0x00 ; 0
42a: d8 01 movw r26, r16
42c: 8d 91 ld r24, X+
42e: 8d 01 movw r16, r26
430: 8f b9 out 0x0f, r24 ; 15
432: 77 9b sbis 0x0e, 7 ; 14
434: fe cf rjmp .-4 ; 0x432
436: 2f 5f subi r18, 0xFF ; 255
438: 3f 4f sbci r19, 0xFF ; 255
43a: b2 e0 ldi r27, 0x02 ; 2
43c: 20 30 cpi r18, 0x00 ; 0
43e: 3b 07 cpc r19, r27
440: a0 f3 brcs .-24 ; 0x42a
442: 8f ef ldi r24, 0xFF ; 255
444: 8f b9 out 0x0f, r24 ; 15
446: 77 9b sbis 0x0e, 7 ; 14
448: fe cf rjmp .-4 ; 0x446
44a: 8f ef ldi r24, 0xFF ; 255
44c: 8f b9 out 0x0f, r24 ; 15
44e: 77 9b sbis 0x0e, 7 ; 14
450: fe cf rjmp .-4 ; 0x44e
452: 9f ef ldi r25, 0xFF ; 255
454: 9f b9 out 0x0f, r25 ; 15
456: 77 9b sbis 0x0e, 7 ; 14
458: fe cf rjmp .-4 ; 0x456
45a: 8f b1 in r24, 0x0f ; 15
45c: 8f 3f cpi r24, 0xFF ; 255
45e: d1 f7 brne .-12 ; 0x454
{
mmc_write_byte(*Buffer++);
}
//CRC-Byte schreiben
mmc_write_byte(0xFF); //Schreibt Dummy CRC
mmc_write_byte(0xFF); //CRC Code wird nicht benutzt
//Wartet auf MMC/SD-Karte Bussy
while (mmc_read_byte() != 0xff){};
//set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv)
MMC_Disable();
460: c3 9a sbi 0x18, 3 ; 24
return(0);
462: 80 e0 ldi r24, 0x00 ; 0
464: 90 e0 ldi r25, 0x00 ; 0
466: 26 96 adiw r28, 0x06 ; 6
468: 0f b6 in r0, 0x3f ; 63
46a: f8 94 cli
46c: de bf out 0x3e, r29 ; 62
46e: 0f be out 0x3f, r0 ; 63
470: cd bf out 0x3d, r28 ; 61
472: df 91 pop r29
474: cf 91 pop r28
476: 1f 91 pop r17
478: 0f 91 pop r16
47a: ff 90 pop r15
47c: ef 90 pop r14
47e: df 90 pop r13
480: cf 90 pop r12
482: 08 95 ret
00000484 <mmc_read_block>:
}
//############################################################################
//Routine zum lesen des CID Registers von der MMC/SD-Karte (16Bytes)
void mmc_read_block(U08 *cmd,U08 *Buffer,U16 Bytes)
//############################################################################
{
484: 0f 93 push r16
486: 1f 93 push r17
488: cf 93 push r28
48a: df 93 push r29
48c: 8b 01 movw r16, r22
48e: ea 01 movw r28, r20
//Sendet Commando cmd an MMC/SD-Karte
if (mmc_write_command (cmd) != 0)
490: 0e 94 47 01 call 0x28e
494: 88 23 and r24, r24
496: 29 f5 brne .+74 ; 0x4e2
498: 9f ef ldi r25, 0xFF ; 255
49a: 9f b9 out 0x0f, r25 ; 15
49c: 77 9b sbis 0x0e, 7 ; 14
49e: fe cf rjmp .-4 ; 0x49c
4a0: 8f b1 in r24, 0x0f ; 15
4a2: 8e 3f cpi r24, 0xFE ; 254
4a4: d1 f7 brne .-12 ; 0x49a
{
return;
}
//Wartet auf Start Byte von der MMC/SD-Karte (FEh/Start Byte)
while (mmc_read_byte() != 0xfe){};
//Lesen des Bolcks (normal 512Bytes) von MMC/SD-Karte
for (U16 a=0;a<Bytes;a++)
4a6: 20 e0 ldi r18, 0x00 ; 0
4a8: 30 e0 ldi r19, 0x00 ; 0
4aa: 2c 17 cp r18, r28
4ac: 3d 07 cpc r19, r29
4ae: 70 f4 brcc .+28 ; 0x4cc
4b0: 9f ef ldi r25, 0xFF ; 255
4b2: f8 01 movw r30, r16
4b4: 0f 5f subi r16, 0xFF ; 255
4b6: 1f 4f sbci r17, 0xFF ; 255
4b8: 9f b9 out 0x0f, r25 ; 15
4ba: 77 9b sbis 0x0e, 7 ; 14
4bc: fe cf rjmp .-4 ; 0x4ba
4be: 8f b1 in r24, 0x0f ; 15
4c0: 80 83 st Z, r24
4c2: 2f 5f subi r18, 0xFF ; 255
4c4: 3f 4f sbci r19, 0xFF ; 255
4c6: 2c 17 cp r18, r28
4c8: 3d 07 cpc r19, r29
4ca: 98 f3 brcs .-26 ; 0x4b2
4cc: 8f ef ldi r24, 0xFF ; 255
4ce: 8f b9 out 0x0f, r24 ; 15
4d0: 77 9b sbis 0x0e, 7 ; 14
4d2: fe cf rjmp .-4 ; 0x4d0
4d4: 8f b1 in r24, 0x0f ; 15
4d6: 8f ef ldi r24, 0xFF ; 255
4d8: 8f b9 out 0x0f, r24 ; 15
4da: 77 9b sbis 0x0e, 7 ; 14
4dc: fe cf rjmp .-4 ; 0x4da
4de: 8f b1 in r24, 0x0f ; 15
{
*Buffer++ = mmc_read_byte();
}
//CRC-Byte auslesen
mmc_read_byte();//CRC - Byte wird nicht ausgewertet
mmc_read_byte();//CRC - Byte wird nicht ausgewertet
//set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv)
MMC_Disable();
4e0: c3 9a sbi 0x18, 3 ; 24
4e2: df 91 pop r29
4e4: cf 91 pop r28
4e6: 1f 91 pop r17
4e8: 0f 91 pop r16
4ea: 08 95 ret
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -