Cómo modificar el experimento del lector de tarjetas USB de la placa Battleship para leer datos de un solo disco, publicación tutorial

Objetivo: solo hay un disco y es un disco SPI FLASH.

Puntos de conocimiento:

1. MAX_LUN se utiliza para representar el número de discos, 0 representa 1, 1 representa 2, 2 representa 3... Y así sucesivamente

2.

1 extern long long Mass_Memory_Size[MAX_LUN+1]

2 extern u32 Mass_Block_Size[MAX_LUN+1]; >

3 extern u32 Mass_ Block_Count[MAX_LUN+1];

Estas tres matrices son muy importantes y se utilizan para describir las características de la información del disco. Mass_Memory_Size representa el tamaño del disco, Mass_Block_Size representa el tamaño del bloque del disco (tamaño del sector) y Mass_Block_Count se utiliza para representar el número de bloques, es decir, el número de sectores. Ese es el número de sectores.

3. Función MAL_Write y función MAL_Read. Se utiliza para implementar operaciones de lectura y escritura de disco subyacentes. Es decir, se debe implementar la interfaz de lectura y escritura USB.

Con el conocimiento anterior, echemos un vistazo al método de modificación:

Paso 1, modifique MAX_LUN a 0 (originalmente 1), es decir, solo hay un disco. MAX_LUN está en el archivo mass_mal.h.

Paso 2, modificar la función MAL_Write y la función MAL_Read. El código modificado es el siguiente:

01 /************** ****** ********************************************** ******* ********** OK

07 1,FALLO

08 ************** ******* ******************************************* ******** ********/

09 u16 MAL_Write(u8 lun, u32 Memory_On_Write(u8), u32 Memory_Off_Write(u8)) lun, u32 Memory_Offset, u32 * Writebuff, u16 Transfer_Length)

10 {

11 u8 STA

12 interruptor (lun)

13 {

14 caso 0:

15 STA=0;

16 SPI_Flash_Write((u8*)Writebuff, Memory_Offset, Transfer_Length

17 // STA=SD_WriteDisk((u8*) Writebuff, Memory_ Offset>>9, Transfer_Length>>9

18 interrupción

19 caso 1:

20 STA=0;

21 SPI_Flash_Write((u8*)Writebuff, Memory_Offset, Transfer_Length);

22 descanso

23 Predeterminado:

24 Devuelve MAL_FAIL;

25 }

26 if(STA!=0)devuelve MAL_FAIL

27 devuelve MAL_OK; p>28 }

29

30 /****************************** *********** **************************************** **** *

31 * Nombre de la función: MAL_Read

32 * Descripción: Leer sectores

33 * Entrada: Ninguna

34 * Salida: Ninguna

35 * Retorno: 0,OK

36 1,FAIL

37 *********** *********** **************************************** ************ ******/

38 u16 MAL_Read(u8 lun, u32 Memory_Offset, u32 Memory_Offset, u32 Memory_Offset) u32 Memory_Offset, u32 *Readbuff, u16 Transfer_Length)

39 {

40 u8 STA

41 interruptor (lun)

42 {

43 caso 0:

44 STA=0;

45 SPI_Flash_Read

((u8*)Readbuff, Memory_Offset, Transfer_Length);

46 //STA=SD_ReadDisk((u8*)Readbuff, Memory_Offset>>9, Transfer_Length>>9); 47 descanso;

48 caso 1:

49 STA=0;

50 SPI_Flash_Read((u8*)Readbuff, Memory_ Offset, Transfer_Length < / p>

51 descanso;

52 Predeterminado:

53 return MAL_FAIL

54 }

55 if (STA ! =0) Devolver MAL_FAIL;

56 Devolver MAL_OK;

57 }

Como puede ver, hemos cambiado el estado del interruptor 0 a operación SPI FLASH. De esta forma, cuando solo hay un disco, el interruptor siempre puede ser 0 y luego la operación es SPI FLASH.

Paso 3, modifique las tres matrices incluyendo Mass_Memory_Size inicializado en la función principal. El código modificado es el siguiente:

01 // if(SD_Initialize())LCD_ShowString(60,130,200,16. , 16, "¡Error de tarjeta SD!"); // Detectar error de tarjeta SD

02 // else //Tarjeta SD normal

03 // {

04 // LCD_ShowString(60,130,200,16,16, "Tamaño de tarjeta SD: MB");

05 // Mass_Memory_ Size[0]=(long long)SD_GetSectorCount()*512; Capacidad de la tarjeta SD (bytes), cuando la capacidad de la tarjeta SD excede 4G, se deben usar dos u32 para representarla

06 // Mass_Block_Size[0] =512 //Porque configuramos la tarjeta SD en; Bytes de operación inicial. Entonces debe tener 512 bytes.

07 // Mass_Block_Count[0]=Mass_Memory_Size[0]/Mass_Block_Size[0];

08 // LCD_ShowNum(164,130,Mass_Memory_Size[0]>>20,5,16 ); // Muestra la capacidad de la tarjeta SD

09 // }

10 if(SPI_FLASH_TYPE!=W25Q64)LCD_ShowString(60,130,200,16,16, "W25Q64 Error!"); //Detectando error en la tarjeta SD

11 else //SPI FLASH normal

12 {

13 Mass_Memory_Size[0]=1024*1024*6;// primeros 6M bytes

14 Mass_Block_Size[0]=512;// Debido a que hemos configurado los bytes de operación de la tarjeta SD en Init en 512, hemos configurado los bytes de operación de la tarjeta SD en 512.

15 Mass_Block_Count[0]=Mass_Memory_Size[0]/Mass_Block_Size[0];

16 LCD_ShowString(60,150,200,16,16, "Tamaño de FLASH SPI: 6144KB"

16 p>

17 }

Como puede ver, enmascaramos la parte de la tarjeta SD, luego enmascaramos las tres matrices Mass_Memory_Size, Mass_Block_Size y Mass_Block_Count, y cambiamos el elemento de la matriz 0 a ser el mismo que el flash SPI (Resultó ser la información relacionada con la memoria flash de la tarjeta SD, completando así la modificación de la rutina.