CN102436428A - SD card file management controller based on FPGA - Google Patents

Abstract

The invention discloses an SD card file management controller based on FPGA, comprising an FPGA chip, a serial configuration chip, an SDRAM memory, a main controller interface, an SD card socket, a FAT32 file management unit and an SD card interface unit; the FAT32 file management unit provides a main controller interface and user commands for operating a file system for the main controller, and the main controller writes the user commands into a register of the SD card file management controller through the interface; the SD card interface unit is responsible for the generation and response reception of SD card commands, as well as the reading and writing of data in the SD card under the control of the FAT32 file management unit; the invention can solve the problems of poor interface versatility and transplantation difficulty of an SD card interface control device, complex operation interface and inconvenience in use, and slow speed of reading and writing SD cards, and provides a file management controller with strong versatility, convenient operation interface and high-speed reading and writing of SD cards.

Description

SD card file management controller based on FPGA

technical field

The invention relates to a device for controlling an SD interface card, in particular to an FPGA-based SD card file management controller.

Background technique

SD card (Secure Digital Memory Card) is a memory card based on semiconductor flash memory technology. It was jointly developed by Panasonic, Toshiba and SanDisk in 1999. At present, people's demand for high-speed storage of large amounts of data is getting higher and higher. As a new generation of data storage device, SD card has the characteristics of small size, high capacity, fast data transmission rate, good mobile flexibility and high security, which well meets the specific needs of the market and is widely used in portable consumer electronics devices and in the field of industrial control.

The data in the SD card is stored in blocks, but in order to organize and manage the data in the SD card more effectively, the data must be organized in a file format. Currently, SD cards generally use the FAT32 file system.

In the face of people's demand for high-speed storage of large amounts of data, there are obvious defects in the SD card interface control devices currently on the market: 1. The speed of reading and writing SD cards is slow. Most of the current SD card interface controllers use the SPI mode of the SD card or the 1-bit SD mode to read and write the SD card, but rarely use the SD mode of the 4-bit data line. Even if the 4-bit SD mode is used, due to the control device The internal buffer is small, and many processing modules are not implemented by hardware, which leads to the low read and write speed. 2. The operation interface provided is complex and inconvenient to use. The current SD card interface control device does not provide a convenient SD card file management function. Users need to be familiar with the physical specification protocol at the bottom of the SD card to complete the operation of the SD card through the control device. 3. The interface provided is not universal and has poor portability. The interface provided by the current SD card interface control device to users rarely adopts a standard bus, and most of them are developed for specific applications, which leads to difficulties in transplantation and poor versatility.

Contents of the invention

The purpose of the invention is to overcome the deficiencies in the prior art and provide a FPGA-based SD card file management controller.

The present invention is achieved through the following technical solutions.

FPGA-based SD card file management controller, including FPGA chip, serial configuration chip, SDRAM memory, main controller interface, SD card socket, among which the FAT32 file management unit and SD card interface unit are implemented inside the FPGA;

The FAT32 file management unit provides the main controller interface and user commands for operating the file system. The main controller can write user commands in the register of the SD card file management controller through this interface to complete the FAT32 file in the SD card. system management;

Under the control of the FAT32 file management unit, the SD card interface unit is responsible for generating SD card commands and receiving responses, as well as reading and writing data in the SD card;

When reading and writing data in the SD card, the SD mode with a 4-bit data line width is adopted;

Described FAT32 file management unit comprises: NIOS II processor, EPCS control module, SDRAM control module, master controller interface module, Avalon bus, Avalon interface module;

The NIOS II processor obtains user commands and data input by the main controller through the main controller interface module, and feeds back information to the main controller;

The NIOS II processor communicates with the SD card interface unit through the Avalon interface module.

The FATFS file system module is transplanted above the FAT32 file management unit.

Described SD card interface unit comprises: read-write buffer FIFO module, SD card data control module, SD card command control module and SD card clock control module;

The read-write buffer FIFO module is responsible for buffering the data when reading and writing the SD card;

The SD card data control module is responsible for the receiving and sending of data on the DAT line and the verification of data;

The SD card command control module is responsible for controlling CMD online command sending and reply receiving;

The SD card clock control module is responsible for controlling the frequency of the CLK clock line to control the data rate of reading and writing the SD card.

The SD card interface unit is composed of FPGA internal logic resources, and uses hardware circuits to realize high-speed data receiving and sending.

The master controller interface includes 8-bit address lines, 8-bit data lines, read enable, write enable, interrupt signal, clock signal, reset signal and chip select signal.

The user commands for operating the file system include creating, opening, reading and writing, and closing files, creating, opening, and closing directories, querying disk capacity, querying free sectors, and reading and writing files in units of sectors or bytes.

The beneficial effects that the present invention has are:

1. The present invention provides the main control of 8-bit address lines ADDR0~ADDR7, 8-bit data lines DATA0~DATA7, read enable RD, write enable WR, interrupt signal INT, clock signal CLK, reset signal RESERT and chip select signal CS Through this interface, the main controller writes specific user commands into the registers of the SD card file management controller to complete the management of the FAT32 file system in the SD card. The master controller can be easily connected with the present invention, and the operation of the present invention is like accessing a synchronous SRAM memory. Solve the defects of the traditional SD card interface controller device interface is not universal, poor portability;

2. The present invention provides common operating files such as creating, opening, reading and writing, and closing files; creating, opening, and closing directories; querying disk capacity, querying free sectors, and reading and writing files in units of sectors or bytes The user command of the system shields the organizational form of the FAT32 file system in the SD card. The user only needs to write a predetermined user command into the corresponding register of the present invention to realize all the above operations. The above mechanism makes the present invention simple to operate and easy to use;

3. The present invention shields the physical specification protocol at the bottom of the SD card for the user. Even if the user is completely unfamiliar with the physical specification protocol at the bottom of the SD card, the present invention can be used to complete the reading and writing of data in the SD card. When reading and writing data in the SD card, the SD mode with 4-bit data line width and large-capacity read and write FIFO are adopted to realize the fast reading and writing of files in the SD card.

Description of drawings

Fig. 1 is the block diagram of SD card file management controller based on FPGA,

Figure 2 is a circuit structure diagram of the FAT32 file management unit in the FPGA,

Figure 3 is a circuit structure diagram of the SD card interface unit in the FPGA,

Figure 4 is a flow chart of the program running on the soft-core processor.

The figure shows:

1--FPGA chip, 2--FAT32 file management unit, 3--SD card interface unit, 4--serial configuration chip, 5--SDRAM memory, 6--main controller interface, 7--NIOS II processing 8-- EPCS control module, 9-- SDRAM control module, 10-- main controller interface module, 11-- Avalon bus, 12-- Avalon interface module, 13-- read and write buffer FIFO module, 14-- SD card data control module, 15--SD card socket, 16--SD card command control module, 17--SD card clock control module.

Detailed ways

The present invention will be described in detail below in conjunction with the embodiments.

As shown in Figure 1, the present invention comprises FPGA chip 1, serial configuration chip 4, SDRAM memory 5, master controller interface 6, SD card socket 15, wherein realize FAT32 file management unit 2 and SD card interface unit 3 in FPGA1 inside Described FAT32 file management unit 2 comprises NIOS II processor 7, EPCS control module 8, SDRAM control module 9 and master controller interface module 10, Avalon bus 11, Avalon interface module 12;

Described SD card interface unit 3 comprises read-write buffer FIFO module 13, SD card data control module 14, SD card command control module 16 and SD card clock control module 17.

As shown in Figure 2 is the circuit structure diagram of the FAT32 file management unit in the FPGA. The FAT32 file management unit is made up of NIOS II processor 7, EPCS control module 8, SDRAM control module 9, master controller interface module 10, Avalon bus 11 and Avalon interface module 12. In the figure, the EPCS control module 8 is connected with the EPCS16 chip adopted by the serial configuration chip 4 through the specific pin of the FPGA chip 1; cs_n_sdram, dq_sdram[15..0], dqm_sdram[1..0], ras_n_sdram, we_n_sdram are the outlet ports of SDRAM control module 9, and are connected with A12~A0, BA1~BA0, CAS of HY57V561620T chip used in SDRAM memory 5 , CKE, CS, DQ15~DQ0, DQM1~DQM0, RAS, and WE ports are connected correspondingly; pins mcu_rst, mcu_clk, mcu_wren, mcu_rden, mcu_int, mcu_address[7..0], mcu_data[7..0] are master controllers sd_interface_clk, sd_interface_reset, sd_cmd_ctrl[15..0], sd_cmd_status[3..0], divider[7..0], sd_data_ctrl[15..0], sd_data_status[3..0] ], nios_data[7..0], nios_wrreq, nios_rdreq, and nios_fifo_clk are the outgoing ports of the Avalon interface module 12.

NIOS II processor 7 controls the serial configuration chip 4 and SDRAM memory 5 outside FPGA by EPCS control module 8 and SDRAM control module 9; command and data, and feedback information to the main controller. The NIOS II processor 7 communicates with the SD card interface unit through the Avalon interface module 12 to realize fast reading and writing of the SD card.

Figure 3 shows the circuit structure diagram of the SD card interface unit. The SD card interface unit 3 is composed of a read-write buffer FIFO module 13 , an SD card data control module 14 , an SD card command control module 16 and an SD card clock control module 17 . In the figure, the read-write buffer FIFO module 13 is responsible for buffering SD card data, and its ports nios_data[7..0], nios_wrreq, nios_rdreq, nios_fifo_clk and Avalon interface module 12's nios_data[7..0], nios_wrreq, nios_rdreq, nios_fifo_clk Connected, host_data[7..0], host_wrreq, host_rdreq, host_fifo_clk are connected with host_data[7..0], host_wrreq, host_rdreq, host_fifo_clk of SD card data control module 14; SD card data control module 14 is responsible for data on the DAT line Receiving and sending and data inspection, its ports reset_n, sd_cmd_ctrl[15..0], sd_cmd_status[3..0] and sd_interface_reset, sd_cmd_ctrl[15..0], sd_cmd_status[3..0] of Avalon interface module 12 Connected, sd_data[3..0] is connected with DAT[3..0] of SD card socket 15; SD card command control module 16 is mainly responsible for controlling CMD online command sending and reply receiving, and its ports reset_n, sd_data_ctrl[15. .0], sd_data_status[3..0] are connected with sd_interface_reset, sd_data_ctrl[15..0], sd_data_status[3..0] of Avalon interface module 12, sd_cmd is connected with CMD of SD card socket 15; SD card clock control Module 17 is responsible for controlling the frequency of the CLK clock line to control the data rate of reading and writing SD cards. Its ports clk, reset_n, divider[7..0] and sd_interface_clk, sd_interface_reset, divider[7..0] of Avalon interface module 12 sd_clk is connected to the clk of the SD card data control module 14, the clk of the SD card command control module 16 and the CLK of the SD card socket 15.

Shown in accompanying drawing 4 is the program flowchart on the soft-core processor. The procedure consists of the following steps:

(1) System initialization;

(2) Whether the main controller writes user commands into the SD card file management controller, if yes, enter step (3), otherwise return to step (2);

(3) Read the command register to obtain the user command number written by the master controller;

(4) Call the interface function corresponding to the FATFS file system module according to the user command number;

(5) The FATFS file system module calls the underlying disk IO module to operate the Avalon bus interface module;

(6) Write the command number and command parameters of the SD card physical layer command to the SD card interface unit through the Avalon bus.

(7) The SD card interface unit generates and sends corresponding commands to the SD card according to the written SD card command number and command parameters.

(8) After the command is executed, go to step (9) otherwise return to step (8) and continue to wait

(9) Return the command response and the execution status of the command, generate an interrupt and return to step (2)

The invention provides 8-bit address lines, which can address 256 units, and these 256 units correspond to 256 registers in the main controller interface module. Table 1 shows the distribution of register space in the interface module of the main controller.

As described in the software flow chart, the main controller can complete disk management and file management operations by writing specific user commands into the registers of the present invention through the main controller interface module. The codes, functions, names, input and output data of various user commands are shown in Table 2 (the suffix H in the table is a hexadecimal number). The details of the various commands are as follows:

CMD_DISK_MOUNT:

This command is used to complete the initialization of the SD card. The main controller first writes the code 00H of the command CMD_DISK_MOUNT into the command register, and then writes 01H into the execution command register, so that the present invention can be operated to complete the mounting and initialization of the SD card. The invention feeds back the response of the command in the state register, and the main controller acquires the state of the SD card by reading the state register. The definitions of all command return values are shown in Table 3. The present invention provides two ways of inquiring and interrupting to notify the main controller that the command sent has been executed. The return status of the CMD_DISK_MOUNT command is FR_OK, FR_NOT_READY. Returns FR_OK if the operation succeeds, and returns FR_NOT_READY if the operation fails. Only when the SD card is initialized successfully can other disk or file operations be performed.

CMD_CREATE_DIR:

This command is used to create a new subdirectory, specifically a folder. When establishing a subdirectory under the root directory, first fill in the directory name (the present invention only supports short file names, so the directory name cannot exceed 8 bytes), attribute fields, and creation time in the registers allocated as shown in Table 2. The attribute field describes the attributes of the file or directory, and its size is 1 byte. Its value 00H represents read-write, 01H represents read-only, 02H represents concealment, 04 represents system file H, 08H represents volume label, 0FH represents that this directory entry is long file name directory entry and has no meaning in the present invention. 10H means directory, 20H means archive. So when creating a new directory, fill in 10H in this field. If the main controller has a real-time clock RTC, write the real time into the creation time register; if the main controller does not have a real-time clock, the system default time is 11:10:01 on October 1, 2011. After filling in the directory information, write the code 01H of the command CMD_CREATE_DIR into the command register, and write 01H into the execution command register to complete the creation of the directory. An interrupt will be generated when the command execution is complete. The main controller can read the status register to query the execution status of the CMD_CREATE_DIR command. The possible states of CMD_CREATE_DIR are FR_OK, FR_DISK_ERR, FR_INT_ERR, FR_NOT_READY, FR_NO_PATH, FR_INVALID_NAME, FR_DENIED, FR_EXIST, FR_WRITE_PROTECTED FR_NO_FILESYSTEM. See Table 3 for the meanings of various return states. When creating a multi-level directory, you need to use the open directory command CMD_OPEN_DIR to open the parent directories of all levels, and then use the new directory command according to the above operation method.

CMD_OPEN_DIR:

This command is used to open an existing directory. When opening a first-level subdirectory under the root directory, first write the name of the directory to be opened in the file name register and not exceed 8 bytes, write the command code 02H of CMD_OPEN_DIR in the command register, and write it to the execution command register Write 01H to execute the command. An interrupt will be generated after the command has been executed. The master controller obtains the operation status of the CMD_OPEN_DIR command by querying the status register. The possible return statuses of the CMD_OPEN_DIR command are FR_OK, FR_DISK_ERR, FR_INT_ERR, FR_NOT_READY, FR_NO_PATH, FR_INVALID_NAME, FR_NO_FILESYSTEM. When opening a multi-level directory, you need to repeatedly use the CMD_OPEN_DIR command to open level by level. The opening method of each level of directory is the same as the way of opening a level of subdirectory under the root directory.

CMD_READ_DIR_STAT:

This command is used to get information about a directory. If the directory is a multi-level directory, you need to use the "Open Directory" command to open the directories one by one. Then write the directory name to be queried into the file name register, write the code 03H of the CMD_READ_DIR_STAT command into the command register, and write 01H into the execution command register to execute the CMD_READ_DIR_STAT command. An interrupt will be generated when the command execution is complete. The execution result of the command is saved in the status register, and the information of the directory is saved in the 32-byte space of the register 03H~22H. The possible return values of the CMD_READ_DIR_STAT command are FR_OK, FR_DISK_ERR, FR_INT_ERR, FR_NOT_READY, FR_NO_FILE, FR_NO_PATH, FR_INVALID_NAME, FR_NO_FILESYSTEM. When the return is FR_OK, it means that the directory information is read successfully, and the main controller can read the relevant information from the register.

CMD_READ_DIR_ITEM:

This command is used to get the directory entries of a directory. Each directory entry contains information such as the file name, extension, attribute byte, last modification time of the file, latest access time, creation date of the file, first cluster number of the file, and length of the file in the directory. Write the directory name into the file name register, write the code 04H of the CMD_READ_DIR_ITEM command into the command register, and write 01H into the execution command register to execute the command. An interrupt will be generated after the command has been executed. The main controller needs to first query the status register to obtain the execution status of the command. When the return value is FR_OK, the register 03H~22H can be read to obtain the information of the directory item. When other values are returned, it indicates that the command execution failed. After reading a directory entry, the master controller can write the CMD_READ_CONTINUE command into the command register and write 01H into the execution command register to continue reading the next directory entry. When all directory entries are read, the return value in the status register is FR_READ_ALL.

CMD_CHANGE_DIR_STAT:

This command is used to modify the attributes of the directory, including the attribute field, directory name, and creation time. If the directory is a multi-level directory, you need to use the open directory command to open the directories at all levels in sequence. Fill data into the attribute field register, file name register, and creation time register, and specify the attribute to be modified in the file information modification flag bit register. 01H means to modify the directory name, 02H means to modify the attribute field, and 04H means to modify the creation time. The main controller can selectively modify these 3 attributes. Write the command code 05H of CMD_CHANGE_DIR_STAT into the command register, and write 01H into the execution command register to execute the command. An interrupt will be generated when the command execution is complete. The master controller can query the status register to obtain the execution status of the command. The possible return values of the command CMD_CHANGE_DIR_STAT are FR_OK, FR_DISK_ERR, FR_INT_ERR, FR_NOT_READY, FR_NO_FILE, FR_NO_PATH, FR_INVALID_NAME, FR_NO_FILESYSTEM, FR_WRITE_PROTECTED, FR_EXIST. When the return value is FR_OK, it indicates that the attribute modification is successful.

CMD_GET_CURRENT_DIR:

This command is used to get the pathname of the current directory. Write the code 06H of the command CMD_GET_CURRENT_DIR into the command register, and write 01H into the execution command register to execute this command. An interrupt will be generated when the command execution is complete. If the command is executed successfully, the value in the status register is FR_OK, and the absolute path name of the directory is in the data register 80H~FFH. The present invention does not support pathnames longer than 128 bytes. The end of the path name is terminated with "\0". The possible return values of this command are FR_OK, FR_DISK_ERR, FR_INT_ERR, FR_NOT_READY, FR_NO_FILESYSTEM.

CMD_CHANGE_DIR:

This command is used to switch directories. Write the directory name to be switched to the data register 80H~FFH, including the absolute path of the directory, and the path name must be less than 128 bytes, write the code 07H of the command CMD_CHANGE_DIR to the command register, and write 01H to the execution command register The command can be executed. The absolute path of the directory starts with "/". "/" indicates the root directory. "/Test" means the "Test" subdirectory under the root directory. "/file.txt" means the file "file.txt" in the root directory. "/Test/file.txt" means the file "file.txt" in the first-level subdirectory "Test" under the root directory. "." indicates the current directory, and ". ." indicates the parent directory of the current directory. An interrupt is generated when the command line completes. If the command is executed successfully, the value in the status register is FR_OK. The possible return values of this command are FR_OK, FR_DISK_ERR, FR_INT_ERR, FR_NOT_READY, FR_NO_FILESYSTEM, FR_INVALID_NAME, FR_NO_PATH.

CMD_DELETE_DIR:

This command is used to delete a directory. Write the directory name to be deleted into the data register 80H~FFH, including the absolute path of the directory, and the path name must be less than 128 bytes, write the code 08H of CMD_DELETE_DIR into the command register, and write 01H into the execution command register. Executable commands. An interrupt will be generated after the command has been executed. If the value in the status register is FR_OK, the command is executed successfully. This command can only be used to delete empty folders, if the folder is not empty, the operation will fail.

CMD_CREATE_FILE:

This command is used to create a file. This command can refer to the relevant details of the CMD_CREATE_DIR command. Fill in the file name, extension, attribute byte, and creation time of the newly created file in sequence in registers 03H~22H, write the code 09H of the command CMD_CREATE_FILE in the command register, and write 01H in the execution command register to execute this Order. An interrupt will be generated after the command has been executed. If the return value in the status register is FR_OK, it means the file is created successfully. The possible return values of this command are FR_OK, FR_DISK_ERR, FR_INT_ERR, FR_NOT_READY, FR_NO_PATH, FR_INVALID_NAME, FR_DENIED, FR_EXIST, FR_WRITE_PROTECTED FR_NO_FILESYSTEM.

CMD_OPEN_FILE:

This command is used to open an existing file. Write the file name to be opened in the file name register, write the code 0AH of the command CMD_OPEN_FILE in the command register, and write 01H in the execution command register to execute this command. An interrupt will be generated after the command has been executed. If the value in the status register is FR_OK, it means that the file is opened successfully. The file must be successfully opened before reading and writing the file and moving the file pointer. The possible return values of this command are FR_OK, FR_DISK_ERR, FR_INT_ERR, FR_NOT_READY, FR_NO_PATH, FR_INVALID_NAME, FR_DENIED, FR_EXIST, FR_WRITE_PROTECTED FR_NO_FILESYSTEM.

CMD_BYTE_READ:

This command is used to read the specified number of bytes of data in bytes. Write the file name into the file name register, and write the number of bytes read into the data size register 23H~26H. The low bit of the byte number is placed in the low address register, and the high bit is placed in the high address register. Write the code 0BH of the command CMD_BYTE_READ into the command register, and write 01H into the execution command register to execute the command. An interrupt will be generated after the command has been executed. If the command is executed successfully, the return value in the status register is FR_OK, and the "number of readable and writable bytes" register is the effective number of bytes in the data register 80H~FFH. The master controller starts to read data from the data register 80H unit according to the value in the "number of readable and writable bytes" register. Data registers 80H~FFH can only store up to 128 bytes of data. When the number of bytes read by the master controller is greater than 128 bytes, it needs to be read in multiple times. After the main controller reads 128 bytes of data from the data register 80H~FFH, write the command CMD_READ_CONTINUE to the command register, and write 01H to the execution command register to read the next 128 bytes of data. When the end of the file is read or the number of bytes read is complete, the value in the status register is FR_READ_ALL. The possible return values of this command are FR_OK, FR_DISK_ERR, FR_INT_ERR, FR_NOT_READY, FR_READ_ALL.

CMD_SECTOR_READ:

This command is used to read files in units of sectors. The usage of this command can refer to CMD_BYTE_READ. Write the file name into the file name register, and write the read sector number into the data size register 23H~26H. The low bit of the sector number is placed in the low address register, and the high bit is placed in the high address register. Write the code 0CH of the command CMD_SECTOR_READ into the command register, and write 01H into the execution command register to execute the command. An interrupt will be generated after the command has been executed. If the command is executed successfully, the return value in the status register is FR_OK, and the "number of readable and writable bytes" register is the effective number of bytes in the data register 80H~FFH. The master controller starts to read data from the data register 80H unit according to the value in the "number of readable and writable bytes" register. Data registers 80H~FFH can only store up to 128 bytes of data, and the size of each sector is an integer multiple of 128 bytes. Therefore, when reading in units of sectors, the master controller needs to repeatedly read 128 bytes of data. After the main controller reads 128 bytes of data from the data register 80H~FFH, write the command CMD_READ_CONTINUE to the command register, and write 01H to the execution command register to read the next 128 bytes of data. When the end of the file is read or the number of read book sectors is completed, the value in the status register is FR_READ_ALL. The possible return values of this command are FR_OK, FR_DISK_ERR, FR_INT_ERR, FR_NOT_READY, FR_READ_ALL.

CMD_BYTE_WRITE:

This command is used to write data to the file in bytes. The usage of this command can refer to the command CMD_BYTE_READ. Write the file name to the file name register, write data to the data register 80H~FFH, write the effective number of bytes in the data register to the "readable and writable bytes" register, and write to the command register Enter the code 0DH of the command CMD_BYTE_WRITE, and write 01H into the execution command register to execute the command. An interrupt will be generated after the command has been executed. If the command is executed successfully, the return value in the status register is FR_OK, and the "number of readable and writable bytes" register is the number of bytes actually written into the file. If the operation fails, the master controller can determine how much data has been written according to the value in the "number of readable and writable bytes" register. Data registers 80H~FFH can only store up to 128 bytes of data. When the number of bytes written by the master controller is greater than 128 bytes, it needs to be written multiple times. After the main controller finishes writing 128 bytes of data, write data again into the data register 80H~FFH, write the number of bytes of this operation into the "number of readable and writable bytes" register, and write to the command register Write the command CMD_WRITE_CONTINUE, and write 01H to the execution command register to continuously write data to the file. The possible return values of this command are FR_OK, FR_DISK_ERR, FR_INT_ERR, FR_NOT_READY.

CMD_SECTOR_WRITE:

This command is used to write data to the file in units of sectors. The usage of this command can refer to the command CMD_BYTE_WRITE. Write the file name to the file name register, write data to the data register 80H~FFH, write the effective number of bytes in the data register to the "readable and writable bytes" register, and write to the command register Enter the code 0EH of the command CMD_SECTOR_WRITE, and write 01H into the execution command register to execute the command. An interrupt will be generated after the command has been executed. If the command is executed successfully, the return value in the status register is FR_OK, and the "number of readable and writable bytes" register is the number of bytes actually written into the file. If the operation fails, the master controller can determine how much data has been written according to the value in the "number of readable and writable bytes" register. Data registers 80H~FFH can only store up to 128 bytes of data, and the sector size of the FAT32 file system is an integer multiple of 128 bytes. The master controller needs to write a sector several times. After the master controller finishes writing 128 bytes of data, write 128 bytes of data into the data register 80H~FFH again, write 128 into the "readable and writable bytes" register, and write Command CMD_WRITE_CONTINUE, write 01H into the execution command register to continuously write data into the file. The possible return values of this command are FR_OK, FR_DISK_ERR, FR_INT_ERR, FR_NOT_READY.

CMD_GET_POINTER:

This command is used to obtain the pointer of the current file when reading and writing files. Write the command CMD_GET_POINTER code 0FH into the command register, and write 01H into the execution command register to execute this command. An interrupt will be generated after the command has been executed. If the command is executed successfully, the return value in the status register is FR_OK, and the data size register 23H~26H is the offset from the file pointer to the beginning of the file. The low bit of the offset is stored at the low address, and the high bit is stored at the high address.

CMD_MOVE_POINTER:

This command is used to move the pointer of the file when reading and writing the file. Write the moving offset into the data size register 23H~26H, and the offset is 4 words. Write the code 10H of the CMD_MOVE_POINTER command into the command register, and write 01H into the execution command register to execute the command. An interrupt will be generated after the command has been executed. If the command is executed successfully, the return value in the status register is FR_OK. The possible return values of this command are FR_OK, FR_DISK_ERR, FR_INT_ERR, FR_NOT_READY.

CMD_GET_FILE_STAT:

This command is used to obtain the read and write attributes of the file, creation time, file size, file first cluster number, last access time of the file, and last modification time of the file. When the file is in the root directory, write the file name into the file name register, write the code 11H of the command CDM_GET_FILE_STAT into the command register, and write 01H into the execution command register to execute the command. An interrupt will be generated after the command has been executed. If the command is executed successfully, the return value in the status register is FR_OK, and the registers 03H~22H are the file information. See Table 1 for the location of each item of information in the register. When the file is located in a multi-level directory, you need to use the open directory command to open the multi-level directory, and then obtain the file information. The possible return values of this command are FR_OK, FR_DISK_ERR, FR_INT_ERR, FR_NOT_READY, FR_NO_FILE, FR_INVALID_NAME, FR_DENIED, FR_EXIST, FR_NO_FILESYSTEM.

CMD_END_OF_FILE:

This command is used to test whether the file pointer has reached the end of the file. Write the command CMD_END_OF_FILE code 12H into the command register, and write 01H into the execution command register to execute the command. An interrupt will be generated after the command has been executed. If the command is executed successfully and the file pointer reaches the end of the file, the return value in the status register is FR_END_OF_FILE; if the end of the file is not reached, FR_OK is returned.

CDM_TEST_FILE_ERROR:

This command is used to test the file for errors. Write the command CMD_TEST_FIL_ERROR code 13H into the command register, and write 01H into the execution command register to execute the command. An interrupt will be generated after the command has been executed. If the command is executed successfully and the file has no errors, the return value in the status register is FR_OK.

CMD_CHANGE_FILE_STAT:

This command is used to modify the attributes of the file, including the attribute field, file name, and creation time. When the file is located in the root directory, fill in the modified data in the attribute field register, file name register, and creation time register, and specify the attribute to be modified in the file information modification flag bit register. 01H means to modify the file name, 02H means to modify the attribute field, and 04H means to modify the creation time. The main controller can selectively modify these 3 attributes. Write the command code 14H of CMD_CHANGE_FILE_STAT into the command register, and write 01H into the execution command register to execute the command. An interrupt will be generated when the command execution is complete. The master controller can query the status register to obtain the execution status of the command. The possible return values of the command CMD_CHANGE_FILE_STAT are FR_OK, FR_DISK_ERR, FR_NO_PATH, FR_NOT_READY, FR_WRITE_PROTECTED, FR_INT_ERR, FR_NO_FILE, FR_INVALID_NAME, FR_EXIST FR_NO_FILESYSTEM. When the return value is FR_OK, it indicates that the attribute modification is successful.

CDM_READ_CONTINUE:

This command is used to continuously read the same file in units of bytes or sectors.

CMD_WRITE_CONTINUE:

This command is used to continuously write the same file in units of bytes or sectors.

CMD_GET_FREE_SECTOR:

This command is used to obtain the free sector number in the SD card. Write the command CMD_GET_FREE_SECTOR code 17H into the command register, and write 01H into the execution command register to execute the command. If the command is executed successfully, the return value in the status register is FR_OK, and the data size register 23H~26H is the idle sector number.

CMD_GET_DISK_CAPACITY:

This command is used to get the capacity of the disk. Write the command CMD_GET_DISK_CAPACITY code 18H into the command register, and write 01H into the execution command register to execute the command. If the command is executed successfully, the return value in the status register is FR_OK, and the data size register 23H~26H is the number of all sectors in the disk.

Table 3 defines all command return values.

Table 1

register address Bytes register definition macro definition 00H 1 status register OPERATION_STATUS 01H 1 execute command register EXECUTE_CMD 02H 1 command register CMD_REGISTER 03~0AH 8 filename register FILE_NAME 0BH~0DH 3 extension register EXTENSION_NAME 0EH 1 Attribute Byte Register FILE_ATTRIBUTE 0FH 1 File information modification flag FILE_MODIFY 10H 1 Creation time 10 milliseconds bit FILE_CRTTIMETENTH 11H~12H 2 file creation time FILE_CRTTIME 13H~14H 2 file creation date FILE_CRTDATE 15H~16H 2 File Last Access Date FILE_LASTACCDATE 17H~18H 2 The high 16 bits of the file start cluster number FILE_FSTCLUSHI 19H~1AH 2 file last modification time FILE_WRITETIME 1BH~1CH 2 file last modification time FILE_WRITED DAYE 1DH~1EH 2 The starting cluster number of the file is lower than 16 FILE_FSTCLUSLO 1FH~22H 4 file length FILE_SIZE 23H~26H 4 Data Size Register OPERATION_SIZE 27H 1 Readable and writable byte count register AVAILABLE_COUNT 80H~FFH the data register DATA_REG_BASE

Table 2

the code Function command name Input data Output Data Whether to generate interrupt 00H SD card initialization CMD_DISK_MOUNT the operating state yes 01H new directory CMD_CREATE_DIR FAT32 short directory entry operating state yes 02H open Directory CMD_OPEN_DIR directory name operating state yes 03H read directory information CMD_READ_DIR_STAT directory name Directory Information and Operational Status yes 04H read directory entry CMD_READ_DIR_ITEM directory name FAT32 short directory entry and operating status yes 05H Modify directory properties CMD_CHANGE_DIR_STAT Directory name and attributes to be modified operating state the 06H get the current directory CMD_GET_CURRENT_DIR the Current directory pathname and operation status yes 07H switch directory CMD_CHANGE_DIR directory name (including pathname) operating state yes 08H delete directory CMD_DELETE_DIR directory name (including pathname) operating state yes 09H create a new file CMD_CREATE_FILE FAT32 short directory entry operating state yes 0AH open a file CMD_OPEN_FILE file name operating state yes 0BH read file in bytes CMD_BYTE_READ filename and number of bytes read Valid byte count and data in the data register yes 0CH read file by sector CMD_SECTOR_READ filename and number of sectors read Valid byte count and data in the data register yes 0DH write file in bytes CMD_BYTE_WRITE File name, number of bytes written, data written, and number of valid bytes in the data register The number of bytes actually written in this operation and the operation status yes 0EH Write files in units of sectors CMD_SECTOR_WRITE File name, number of sectors written, data written and number of valid bytes in the data register The number of bytes actually written in this operation and the operation status yes 0FH Get the current file pointer CMD_GET_POINTER file name The offset and operation status of the current file pointer yes 10H Move the pointer of the current file CMD_MOVE_POINTER filename and offset in bytes operating state yes 11H Get file information CMD_GET_FILE_STAT file name FAT32 short directory entry operation status yes 12H Test whether the end of the file has been reached CMD_END_OF_FILE file name operating state yes 13H Test file for errors CMD_TEST_FILE_ERROR file name operating state yes 14H modify file properties CMD_CHANGE_FILE_STAT File name, attribute indicator bits, and file attributes operating state yes 15H continue reading CMD_READ_CONTINUE the operating state yes 16H continue writing CMD_WRITE_CONTINUE the operating state yes 17H Query free sector number CMD_GET_FREE_SECTOR the Free sector number and operating status yes 18H Query disk capacity CMD_GET_DISK_CAPACITY the The total number of sectors and the operating status of the disk yes

table 3

the code state name Remark 00H FR_OK The command operation succeeded 01H FR_NOT_READY Failed to hang on the SD card or initialize the file system 02H FR_INT_ERR request failed 03H FR_DISK_ERR unrecoverable error 04H FR_NO_FILE The specified file could not be found 05H FR_NO_PATH The specified path could not be found 06H FR_INVALID_NAME The specified path name is invalid 07H FR_DENIED The specified operation is denied 08H FR_EXIST The specified directory name or file name already exists 09H FR_WRITE_PROTECTED Write to a write-protected disk 0AH FR_NO_FILESYSTEM There is no FAT32 file system on the SD card 0BH FR_TOO_MANY_OPEN_FILES Too many open files than allowed 0CH FR_READ_ALL All read/write operations complete 0DH FR_END_OF_FILE The file pointer reaches the end of the file

Claims (6)

1. FPGA-based SD card file management controller, characterized in that it includes FPGA chip (1), serial configuration chip (4), SDRAM memory (5), main controller interface (6), SD card socket (15) , where the FAT32 file management unit (2) and the SD card interface unit (3) are implemented inside the FPGA (1); The FAT32 file management unit (2) provides the main controller interface (6) and user commands for operating the file system, and the main controller writes the user command in the register of the SD card file management controller through the interface. Can complete the management of the FAT32 file system in the SD card; The SD card interface unit (3) is under the control of the FAT32 file management unit (2), responsible for generating SD card commands and receiving responses, as well as reading and writing data in the SD card; When reading and writing data in the SD card, the SD mode with a 4-bit data line width is adopted. 2. a kind of SD card file management controller based on FPGA according to claim 1, is characterized in that: described FAT32 file management unit (2) comprises NIOS II processor (7), EPCS control module (8) , SDRAM control module (9), main controller interface module (10), Avalon bus (11), Avalon interface module (12); The NIOS II processor (7) obtains user commands and data input by the main controller through the main controller interface module (10), and feeds back information to the main controller; Described NIOS II processor (7) communicates with SD card interface unit (3) by Avalon interface module (12); The NIOS II processor (7) is connected to the serial configuration chip (4) and the SDRAM memory (5) outside the FPGA respectively through the EPCS control module (8) and the SDRAM control module (9). 3. An FPGA-based SD card file management controller according to claim 1, characterized in that: the FATFS file system module is transplanted on the FAT32 file management unit (2). 4. a kind of SD card file management controller based on FPGA according to claim 1, is characterized in that: described SD card interface unit (3) comprises read-write buffer FIFO module (13), SD card data control module (14), SD card command control module (16) and SD card clock control module (17); The read-write buffer FIFO module (13) is responsible for buffering the data when reading and writing the SD card, The SD card data control module (14) is responsible for receiving and sending data on the DAT line and verifying data, The SD card command control module (16) is responsible for controlling CMD online command sending and reply receiving, The SD card clock control module (17) is responsible for controlling the frequency of the CLK clock line to control the data rate of reading and writing the SD card. 5. a kind of SD card file management controller based on FPGA according to claim 1, it is characterized in that described master controller interface is 8 address lines, 8 data lines. 6. a kind of SD card file management controller based on FPGA according to claim 1, it is characterized in that the user order of described operation file system comprises newly-built, open, read and write, close file, new-build, open, close directory, Disk capacity query, free sector query, read and write files in units of sectors or bytes.

Images