Red de conocimiento informático - Material del sitio web - Cómo modificar el experimento del lector de tarjetas USB de la placa Battleship para leer datos de un solo disco, publicación tutorial

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

Código fuente: experimento de versión de registro de tablero de acorazado 50 experimento de lector de tarjetas USB.

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.