PIC单片机USB MSC的应用：PC 利用 MMC/SD 卡作为储存设备进行读写

单片机的USB接口，通常用法，

1）HID  是Human Interface Device的缩写，由其名称可以了解HID设备是直接与人交互的设备，例如键盘、鼠标与游戏杆等。不过HID设备并不一定要有人机接口，只要符合HID类别规范的设备都是HID设备。（参考百度 https://baike.baidu.com/item/USB-HID）
2）CDC 虚拟串口，可与PC机直接联机通讯，如同RS232。
3）USB MSC (Mass Storage class) MSC是一种计算机和移动设备之间的传输协议，它允许一个通用串行总线（USB）设备来访问主机的计算设备，使两者之间进行文件传输。设备包括：移动硬盘，移动光驱，U盘，SD、TF等储存卡读卡器，数码相机，手机等等。

..........

注意：

每一个USB设备，都需要一个独立的身份编码 （ID），它由 2 组数字组成，一个是开发商代码（Vender ID），另一个是产品代码（Product ID）。如果是PIC使用者，可以向Microchip公司申请获得免费的身份编码。

USB MSC 的应用与前面介绍的USB CDC 和 USB HID 相比较，USB MSC 的内容比较多，需要多花一些时间。

以下介绍一个简单的从USB接口对 MMC/SD 卡进行读/写数据的简单测试程序。希望大家能够喜欢。

让PC认为 MMC/SD 卡作为储存设备 (Storage) 进行运作

主程序：

1. /*
   
2. * Project name:
   
3.      MassStorageDevice.vtft
   
4. * Generated by:
   
5.      Visual TFT
   
6. * Description:
   
7.      Example using EasyPIC Fusion v7 board as mass storage device. Before using it, insert microSD card
   
8.      in the card slot on EasyPIC Fusion v7 board and plug usb cable to connect with PC.
   
9.      After connection with PC, mikromedia is detected as mass storage device wich size is
   
10.      size of microSD card inserted.
    
11. * Test configuration:
    
12.      MCU:             P18F87J50
    
13.      Dev.Board:       MikroMMB_for_PIC18FJ_hw_rev_1.10_9A
    
14.                       http://www.mikroe.com/mikromedia/pic18fj/
    
15.      Oscillator:      HS-PLL, 48.000MHz
    
16.      SW:              mikroC PRO for PIC
    
17.                       http://www.mikroe.com/mikroc/pic/
    
18. */
    
19. 
    
20. #include "__Lib_USB_Device.h"
    
21. 
    
22. // MMC module connections
    
23. sbit Mmc_Chip_Select           at LATD0_bit;  // for writing to output pin always use latch
    
24. sbit Mmc_Chip_Select_Direction at TRISD0_bit;
    
25. // eof MMC module connections
    
26. 
    
27. void interrupt(){
    
28.   USBDev_IntHandler();
    
29. }
    
30. 
    
31. void main() {
    
32. 
    
33.   PLLEN_bit = 1;
    
34.   Delay_ms(150);
    
35.   WDTCON.B4 = 1;
    
36.   ANCON0 = 0xF0; // All pins to digital
    
37.   ANCON1 = 0xFF;
    
38.   WDTCON.B4 = 0;
    
39. 
    
40.   SPI1_Init_Advanced(_SPI_MASTER_OSC_DIV4, _SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_LOW, _SPI_LOW_2_HIGH);
    
41. 
    
42.   USBDev_MSCInit();
    
43.   USBDev_Init();
    
44. 
    
45.   IPEN_bit = 1;
    
46.   USBIP_bit = 1;
    
47.   USBIE_bit = 1;
    
48.   GIEH_bit = 1;
    
49. 
    
50.   while(1){
    
51.     USBDev_MSCMain();
    
52.   }
    
53. 
    
54. }

复制代码

MMC/ＳＤ卡驱动程序：

1. #include <stdint.h>
   
2. 
   
3. // Mode sense data
   
4. static const uint8_t MODE_SENSE_6_DATA[8] = {
   
5.   0x00,
   
6.   0x00,
   
7.   0x00,
   
8.   0x00,
   
9.   0x00,
   
10.   0x00,
    
11.   0x00,
    
12.   0x00
    
13. };
    
14. 
    
15. 
    
16. // Standard Inquiry Data
    
17. static const uint8_t STD_INQUIRY_DATA[36] = {
    
18.   0x00, // Direct access block device
    
19.   0x80, // RMB bit set to one indicates that the medium is removable
    
20.   0x00, // ISO(7..6) ECMA(5..3) ANSI(2..0) Version
    
21.   0x02, // Response Data Format
    
22.   0x1F, // Additional length (31)
    
23.   0x00, // Reserved
    
24.   0x00, // Reserved
    
25.   0x00, // Reserved
    
26.   'M', 'I', 'K', 'R', 'O', 'E', ' ', ' ', // Vendor Information
    
27.   'm', 'i', 'c', 'r', 'o', 'S', 'D', ' ', // Product identification
    
28.   'F', 'l', 'a', 's', 'h', ' ', ' ', ' ',
    
29.   '1', '.', '0', '0'                      // Product Revision Level n.nn
    
30. };
    
31. 
    
32. // USB Mass storage Page 0 Inquiry Data
    
33. static const uint8_t UNIT_SERIAL_NUMBER[7] = {
    
34.   0x00, // Peripheral qualifier[7..5] device type[4..0]
    
35.   0x80, // Page Code 80h
    
36.   0x00, // Reserved
    
37.   0x03, // Page Length
    
38.   0x00, // Product Serial Nnumber
    
39.   0x00,
    
40.   0x00
    
41. };
    
42. 
    
43. static uint8_t tmpStorageBuff[36];
    
44. 
    
45. // Storage callbacks
    
46. static uint8_t StorageInit();
    
47. static uint8_t StorageIsReady();
    
48. static uint8_t StorageIsWriteProtected();
    
49. static uint8_t StorageGetCapacity(uint32_t* blockNum, uint32_t *blockSize);
    
50. static uint8_t StorageRead(uint8_t *buffer, uint32_t lba, uint16_t blockNum);
    
51. static uint8_t StorageWrite(uint8_t *buffer, uint32_t lba, uint16_t blockNum);
    
52. static uint8_t* StorageGetInquiryData(uint8_t vpd);
    
53. static uint8_t* StorageGetStdInquiryData();
    
54. static uint8_t* StorageGetModeSenseData();
    
55. 
    
56. typedef struct {
    
57.   uint8_t(*StorageInit)();
    
58.   uint8_t(*StorageIsReady)();
    
59.   uint8_t(*StorageIsWriteProtected)();
    
60.   uint8_t(*StorageGetCapacity)(uint32_t *blockNum, uint32_t * blockSize);
    
61.   uint8_t(*StorageRead) (uint8_t *buffer, uint32_t lba, uint16_t blockNum);
    
62.   uint8_t(*StorageWrite)(uint8_t *buffer, uint32_t lba, uint16_t blockNum);
    
63.   uint8_t * (*StorageGetInquiryData)(uint8_t vpd);
    
64.   uint8_t * (*StorageGetStdInquiryData)();
    
65.   uint8_t * (*StorageGetModeSenseData)();
    
66. } TMSCStorageCB;
    
67. 
    
68. TMSCStorageCB USBDev_MSCStorageCB = {
    
69.   StorageInit,
    
70.   StorageIsReady,
    
71.   StorageIsWriteProtected,
    
72.   StorageGetCapacity,
    
73.   StorageRead,
    
74.   StorageWrite,
    
75.   StorageGetInquiryData,
    
76.   StorageGetStdInquiryData,
    
77.   StorageGetModeSenseData
    
78. };
    
79. 
    
80. // STORAGE IMPLEMENTATION
    
81. 
    
82. static void StorageConstToRam(const uint8_t* fromBuffer, uint8_t* toBuffer, uint16_t len){
    
83.   uint16_t i;
    
84.   for(i = 0; i < len; i++){
    
85.     toBuffer[i] = fromBuffer[i];
    
86.   }
    
87. }
    
88. 
    
89. ////////////////////////////////////////////////////////////////////////////////
    
90. // This is a wrapper for retrieving number of sector device implements.
    
91. // It is used to get sector count of the device (for fat formatting purpose,
    
92. // assumed sector size is 512 bytes).
    
93. 
    
94. // MMC GetMmcSectorCount return codes
    
95. static const uint8_t  MMC_OK     =   0,
    
96.                       MMC_ERROR  =   255;
    
97.                      
    
98. static uint8_t GetMmcSectorCount(uint32_t *scCnt)
    
99. {
    
100.     uint8_t  csdbuf[16];
     
101.     uint16_t c_size, c_size_mult, mult,
     
102.            read_bl_len, block_len;
     
103.     uint32_t size, blocknr;
     
104. 
     
105.     // determine MMC/SD card size in MB
     
106.     if (Mmc_Read_Csd(csdbuf) != MMC_OK)
     
107.     {
     
108.         return MMC_ERROR;
     
109.     }
     
110. 
     
111.     // is it version 2.0?
     
112.     if (1 == ((csdbuf[0] & 0xC0) >> 6))
     
113.     {
     
114.         size  = 0;                  size <<= 8;
     
115.         size += csdbuf[7] & 0x3F;   size <<= 8;
     
116.         size += csdbuf[8];          size <<= 8;
     
117.         size += csdbuf[9];          size <<= 0;
     
118. 
     
119.         // size is in 0.5MB, get size in sectors (assumed 512 bytes sector size)
     
120.         size *= 1024;
     
121.     }
     
122.     // if not, it's version 1.xx
     
123.     else
     
124.     {
     
125.         c_size      = ((csdbuf[8] & 0xC0) >> 6) +
     
126.                       ((unsigned) csdbuf[7] << 2) +
     
127.                       (((unsigned) csdbuf[6] & 0x03) << 10);
     
128.         c_size_mult = (csdbuf[10] & 0x80) +
     
129.                       (((unsigned) csdbuf[9] & 0x03) << 8);
     
130.         c_size_mult = c_size_mult >> 7;
     
131. 
     
132.         read_bl_len = csdbuf[5] & 0x0f;
     
133. 
     
134.         mult = 1;
     
135.         mult = mult << (c_size_mult + 2);
     
136. 
     
137.         blocknr = (c_size + 1) * (long) mult;
     
138.         block_len = 1;
     
139.         block_len = block_len << read_bl_len;
     
140. 
     
141.         size = block_len * blocknr;
     
142. 
     
143.         // size is in 1B, get size in sectors (assumed 512 bytes sector size)
     
144.         size /= 512;
     
145.     }
     
146. 
     
147.     *scCnt = size;
     
148. 
     
149.     return MMC_OK;
     
150. }
     
151. 
     
152. static uint8_t  storageInitStatus;   // storage initializtion status
     
153. // Initializing storage
     
154. static uint8_t StorageInit() {
     
155.   // initialize a MMC card
     
156.   storageInitStatus = Mmc_Init();
     
157.   return storageInitStatus;
     
158. }
     
159. 
     
160. // Get storage capacity, number of blocks and block size
     
161. static uint8_t StorageGetCapacity(uint32_t* blockNum, uint32_t *blockSize) {
     
162.   GetMmcSectorCount(blockNum);
     
163.   *blockSize = 512;
     
164.   return 0;
     
165. }
     
166. 
     
167. // Read storage to buffer
     
168. static uint8_t StorageRead(uint8_t *buffer, uint32_t lba, uint16_t blockNum) {
     
169.   uint8_t status;
     
170.   status = 0;
     
171.   Mmc_Multi_Read_Start(lba);
     
172.   while (blockNum) {
     
173.     Mmc_Multi_Read_Sector(buffer);
     
174.     buffer += 512;
     
175.     blockNum--;
     
176.   }
     
177.   Mmc_Multi_Read_Stop();
     
178.   return status;
     
179. }
     
180. 
     
181. // Return storage status
     
182. static uint8_t StorageIsReady() {
     
183.   if(storageInitStatus)
     
184.     return 0; // storage is not ready
     
185.   else
     
186.     return 1;  // storage is ready
     
187. }
     
188. 
     
189. // Write to storage
     
190. static uint8_t StorageWrite(uint8_t *buffer, uint32_t lba, uint16_t blockNum) {
     
191.   uint8_t status;
     
192.   status = 0;
     
193.   while (blockNum) {
     
194.     status |= Mmc_Write_Sector(lba, buffer);
     
195.     lba++;
     
196.     buffer += 512;
     
197.     blockNum--;
     
198.   }
     
199.   return status;
     
200. }
     
201. 
     
202. // Get storage protection status
     
203. static uint8_t StorageIsWriteProtected() {
     
204.   return 0;
     
205. }
     
206. 
     
207. // Return storage inquiry data
     
208. static uint8_t* StorageGetInquiryData(uint8_t vpd) {
     
209.   StorageConstToRam(UNIT_SERIAL_NUMBER, tmpStorageBuff, 7);
     
210.   return tmpStorageBuff;
     
211. }
     
212. 
     
213. // Get standard inquiry data
     
214. static uint8_t* StorageGetStdInquiryData() {
     
215.   StorageConstToRam(STD_INQUIRY_DATA, tmpStorageBuff, 36);
     
216.   return tmpStorageBuff;
     
217. }
     
218. 
     
219. // Get mode sense data
     
220. static uint8_t* StorageGetModeSenseData() {
     
221.   StorageConstToRam(MODE_SENSE_6_DATA, tmpStorageBuff, 8);
     
222.   return tmpStorageBuff;
     
223. }
     
224. 
     
225. // END OF STORAGE IMPLEMENTATION

复制代码

USB MSC 驱动程序：

1. #include <stdint.h>
   
2. 
   
3. const uint8_t  _USB_MSC_MANUFACTURER_STRING[]  = "MikroElektronika";
   
4. const uint8_t  _USB_MSC_PRODUCT_STRING[]       = "Mass Storage by Mikroe";
   
5. const uint8_t  _USB_MSC_SERIALNUMBER_STRING[]  = "0x00000002";
   
6. const uint8_t  _USB_MSC_CONFIGURATION_STRING[] = "Mass Storage Config Desc string";
   
7. const uint8_t  _USB_MSC_INTERFACE_STRING[]     = "Mass Storage mscInterface Desc string";
   
8. 
   
9. const uint8_t  _USB_MSC_STR_DESC_SIZE          = 4;
   
10. const uint16_t _USB_MSC_STR_DESC_LANGID        = 0x409;
    
11. 
    
12. const uint8_t _USB_MSC_CONFIG_DESC_SIZ  = 32;   // Configuration descriptor size
    
13. const uint8_t _USB_MSC_PACKET_MAX_SIZE  = 64;   // Max packet size for endpoint
    
14. const uint8_t _USB_MSC_IN_EP_NUM  = 1;          // IN endpoint number
    
15. const uint8_t _USB_MSC_OUT_EP_NUM = 1;          // OUT endpoint number
    
16. 
    
17. //String Descriptor Zero, Specifying Languages Supported by the Device
    
18. const uint8_t USB_MSC_LangIDDesc[_USB_MSC_STR_DESC_SIZE] = {
    
19.   _USB_MSC_STR_DESC_SIZE,
    
20.   _USB_DEV_DESCRIPTOR_TYPE_STRING,
    
21.   _USB_MSC_STR_DESC_LANGID & 0xFF,
    
22.   _USB_MSC_STR_DESC_LANGID >> 8,
    
23. };
    
24. 
    
25. 
    
26. // device descriptor
    
27. const uint8_t USB_MSC_device_descriptor[] = {
    
28.   0x12, // bLength
    
29.   0x01, // bDescriptorType
    
30.   0x00, // bcdUSB
    
31.   0x02,
    
32.   0x00, // bDeviceClass
    
33.   0x00, // bDeviceSubClass
    
34.   0x00, // bDeviceProtocol
    
35.   0x40, // bMaxPacketSize0
    
36.   0x00, // idVendor
    
37.   0x00,
    
38.   0x02, // idProduct
    
39.   0x00,
    
40.   0x00, // bcdDevice
    
41.   0x02,
    
42.   0x01, // iManufacturer
    
43.   0x02, // iProduct
    
44.   0x03, // iSerialNumber
    
45.   0x01  // bNumConfigurations
    
46. 
    
47. };
    
48. 
    
49. // Configuration descriptor with all interfaces and endpoints
    
50. // descriptors for all of the interfaces
    
51. const uint8_t USB_MSC_cfg_descriptor[_USB_MSC_CONFIG_DESC_SIZ] = {
    
52.   // Configuration descriptor
    
53.   0x09,                                   // bLength: Configuration Descriptor size
    
54.   _USB_DEV_DESCRIPTOR_TYPE_CONFIGURATION, // bDescriptorType: Configuration
    
55.   _USB_MSC_CONFIG_DESC_SIZ & 0xFF,        // wTotalLength: Bytes returned
    
56.   _USB_MSC_CONFIG_DESC_SIZ >> 8,
    
57.   0x01,                                   // bNumInterfaces: 1 interface
    
58.   0x01,                                   // bConfigurationValue: Configuration value
    
59.   0x04,                                   // iConfiguration: Index of string descriptor describing the configuration
    
60.   0xC0,                                   // bmAttributes: self powered
    
61.   0x32,                                   // MaxPower 100 mA: maximum power consuption of the device
    
62. 
    
63.   // Mass Storage interface
    
64.   0x09,                                   // bLength: interface descriptor size
    
65.   0x04,                                   // bDescriptorType: interface descriptor type
    
66.   0x00,                                   // bInterfaceNumber: Number of Interface
    
67.   0x00,                                   // bAlternateSetting: Alternate setting
    
68.   0x02,                                   // bNumEndpoints: Number of endpoints
    
69.   0x08,                                   // bInterfaceClass: MSC
    
70.   0x06,                                   // bInterfaceSubClass : SCSI transparent
    
71.   0x50,                                   // nInterfaceProtocol
    
72.   0x05,                                   // iInterface: Index of string descriptor
    
73. 
    
74.   // Mass Storage Endpoints
    
75.   0x07,                                   // bLength: Endpoint Descriptor size
    
76.   _USB_DEV_DESCRIPTOR_TYPE_ENDPOINT,      // bDescriptorType: endpoint descriptor type
    
77. 
    
78.   0x80 | _USB_MSC_IN_EP_NUM,              // bEndpointAddress: Endpoint Address (IN)
    
79.   0x02,                                   // bmAttributes: Bulk endpoint
    
80.   _USB_MSC_PACKET_MAX_SIZE,               // wMaxPacketSize: maximum packet size for endpoint
    
81.   0x00,
    
82.   0x00,                                   // bInterval: Polling Interval
    
83. 
    
84.   0x07,                                   // bLength: Endpoint Descriptor size
    
85.   _USB_DEV_DESCRIPTOR_TYPE_ENDPOINT,      // bDescriptorType: endpoint descriptor type
    
86.   _USB_MSC_OUT_EP_NUM,                    // bEndpointAddress: Endpoint Address (OUT)
    
87.   0x02,                                   // bmAttributes: Bulk endpoint
    
88.   _USB_MSC_PACKET_MAX_SIZE,               // wMaxPacketSize: maximum packet size for endpoint
    
89.   0x00,
    
90.   0x00                                    // bInterval
    
91. };

复制代码

详细内容，请参考：http://www.51hei.com/bbs/dpj-138111-1.html

如果你使用的是8位单片机，仔细看MikroE公司的8位编译器，在该软件的Help里面有详细说明。MikroE的函数只支持他们的编译器。函数的内部Code也是不公开的。Microchip单片机的USB模块技术是非常成熟的，如果你希望写自己的USB函数，无论是CDC，HID或者MSC，都可以参考Microchip的相关Datasheet，应该不是很困难的，只是很费时间。

oldspring 发表于 2018-11-4 20:11
这个就是详细代码，连接的内容你仔细再看看。不知道你是用哪一种PIC单片机。8 位？16位？或者32位？

点击详细内容就会转到：推荐一款PIC单片机编译器

oldspring 发表于 2018-11-4 20:11
这个就是详细代码，连接的内容你仔细再看看。不知道你是用哪一种PIC单片机。8 位？16位？或者32位？

我用的是pic18f67j94，就是在主程序里面的所调用的USB函数只有函数名，求楼主分享函数内容，USBDev_IntHandler()、USBDev_MSCMain();

这个就是详细代码，连接的内容你仔细再看看。不知道你是用哪一种PIC单片机。8 位？16位？或者32位？

楼主，求完整代码

楼主有完整的代码分享吗？我点了详细内容转成另一个帖子了。