标题: 单片机读写CH375 SD卡U盘程序源码(详细注释)电路设计资料 [打印本页]
作者: 小徐    时间: 2018-11-19 11:03
标题: 单片机读写CH375 SD卡U盘程序源码(详细注释)电路设计资料
单片机读写SD卡与U盘完整资料包内容预览（内含几种不同设计的模块与源代码）：


CH375电路原理图如下：




CH375的单片机驱动程序如下:
  1. /*
  2. ****************************************
  3. **  USB Host File Interface for CH375 **
  4. **  TC2.0@PC, KC7.0@MCS51             **
  5. ****************************************
  6. */
  7. /* CH375 主机文件系统接口 */
  8. /* 支持: FAT12/FAT16/FAT32 */

  10. /* MCS-51单片机C语言的U盘文件读写示例程序, 适用于89C52或者更大程序空间的单片机,也适用于ATMEL/PHILIPS/SST等具有1KB内部RAM的单片机 */
  11. /* 该程序将U盘中的/C51/CH375HFT.C文件中的前200个字符显示出来,
  12.    如果找不到原文件CH375HFT.C, 那么该程序将显示C51子目录下所有以CH375开头的文件名,
  13.    如果找不到C51子目录, 那么该程序将显示根目录下的所有文件名,
  14.    最后将程序ROM中的一个字符串写入写入新建的文件"NEWFILE.TXT"中
  15. */
  16. /* CH375的INT#引脚采用查询方式处理, 数据复制方式为"单DPTR复制",兼容性最好但是速度最慢,
  17.    本例只使用512字节的外部RAM, 同时作为磁盘数据缓冲区和文件数据缓冲区, 演示没有外部RAM但是单片机的内置RAM大于768字节的应用 */

  19. /* 本例以字节为单位读写U盘文件,读写速度较扇区模式慢,但是由于字节模式读写文件不需要文件数据缓冲区FILE_DATA_BUF,
  20.    所以总共只需要600字节的RAM,适用于单片机硬件资源有限、数据量小并且读写速度要求不高的系统 */

  22. /*#define         NO_DEFAULT_CH375_INT                1*/        /* 在应用程序中定义NO_DEFAULT_CH375_INT可以禁止默认的中断处理程序,然后用自行编写的程序代替它 */
  23. /*#define                CH375HF_NO_CODE                1*/
  24. #include "CH375.H"

  26. #ifdef        NO_DEFAULT_CH375_INT                        /* 自行编写中断处理程序,加上了超时处理,并且在等待中断的过程中可以做其它事 */
  27. void xQueryInterrupt( void )                        /* 查询CH375中断并更新中断状态,该程序基本框架可以参考CH375HF?.H文件 */
  28. {
  29.         UINT16        i;
  30.         for ( i = 65535; i != 0; i -- ) {  /* 正常情况下该过程为几毫秒到几十毫秒,偶尔也会达到几百毫秒 */
  31.                 if ( CH375_INT_WIRE == 0 ) break;  /* 如果CH375的中断引脚输出低电平则说明CH375操作完成 */
  32. /*                if ( ( CH375_CMD_PORT & 0x80 ) == 0 ) break;  对于CH375B芯片,也查询CH375B的命令端口的位7为0说明中断引脚输出低电平 */
  33.         }
  34.         if ( i == 0 )
  35.         CH375_CMD_PORT = CMD_GET_STATUS;  /* 获取当前中断状态 */
  36.         mDelay2uS( );  /* 操作无意义,用于至少延时2uS,可以用多个NOP空操作指令实现 */
  37.         CH375IntStatus = CH375_DAT_PORT;  /* 获取中断状态 */
  38.         if ( CH375IntStatus == USB_INT_DISCONNECT ) CH375DiskStatus = DISK_DISCONNECT;  /* 检测到USB设备断开事件 */
  39.         else if ( CH375IntStatus == USB_INT_CONNECT ) CH375DiskStatus = DISK_CONNECT;  /* 检测到USB设备连接事件 */
  40. }
  41. #endif

  43. /* 以毫秒为单位延时,不精确,适用于24MHz时钟 */
  44. void        mDelaymS( UINT8 delay )
  45. {
  46.         unsigned char        i, j, c;
  47.         for ( i = delay; i != 0; i -- ) {
  48.                 for ( j = 200; j != 0; j -- ) c += 3;  /* 在24MHz时钟下延时500uS */
  49.                 for ( j = 200; j != 0; j -- ) c += 3;  /* 在24MHz时钟下延时500uS */
  50.         }
  51. }

  53. /* 将程序空间的字符串复制到内部RAM中,返回字符串长度 */
  54. UINT8        mCopyCodeStringToIRAM( UINT8 idata *iDestination, UINT8 code *iSource )
  55. {
  56.         UINT8        i = 0;
  57.         while ( *iDestination = *iSource ) {
  58.                 iDestination ++;
  59.                 iSource ++;
  60.                 i ++;
  61.         }
  62.         return( i );
  63. }

  65. /* 检查操作状态,如果错误则显示错误代码并停机 */
  66. void        mStopIfError( UINT8 iError )
  67. {
  68.         if ( iError == ERR_SUCCESS ) return;  /* 操作成功 */
  69.         printf( "Error: %02X\n", (UINT16)iError );  /* 显示错误 */
  70.         while ( 1 ) {
  71.                 LED_UDISK_IN( );  /* LED闪烁 */
  72.                 mDelaymS( 100 );
  73.                 LED_UDISK_OUT( );
  74.                 mDelaymS( 100 );
  75.         }
  76. }

  78. void host( ) {
  79.         UINT8        i, c, TotalCount;
  80.         UINT8        code *pCodeStr;
  81.         UINT16        EnumCount;

  83. #if DISK_BASE_BUF_LEN == 0
  84.         pDISK_BASE_BUF = &my_buffer[0];  /* 不在.H文件中定义CH375的专用缓冲区,而是用缓冲区指针指向其它应用程序的缓冲区便于合用以节约RAM */
  85. #endif

  87.         i = CH375LibInit( );  /* 初始化CH375程序库和CH375芯片,操作成功返回0 */
  88.         mStopIfError( i );
  89.         while ( 1 ) {
  90.                 printf( "Insert USB disk\n" );
  91.                 while ( CH375DiskStatus < DISK_CONNECT ) {  /* 等待U盘插入 */
  92.                
  93. /*                        if ( CH375_INT_WIRE == 0 ) xQueryInterrupt( );*/  /* 如果CH375中断,那么查询CH375中断并更新中断状态,可以改成中断方式 */
  94.                         mDelaymS( 100 );  /* 没必要频繁查询 */
  95.                         if ( CH375DiskConnect( ) == ERR_SUCCESS ) break;        /* 查询方式: 检查磁盘是否连接,返回成功说明连接 */
  96.                 }
  97.                 LED_UDISK_IN( );  /* LED亮 */
  98.                 mDelaymS( 250 );  /* 延时,可选操作,有的USB存储器需要几十毫秒的延时 */

  100. /* 检查U盘是否准备好,但是某些U盘必须要执行这一步才能工作 */
  101.                 for ( i = 0; i < 5; i ++ ) {  /* 有的U盘总是返回未准备好,不过可以被忽略 */
  102.                         mDelaymS( 100 );
  103.                         printf( "Ready ?\n" );
  104. //                        if ( CH375DiskReady( ) == ERR_SUCCESS ) break;  /* 查询磁盘是否准备好,不支持CH375S,节约代码空间 */
  105.                         if ( CH375sDiskReady( ) == ERR_SUCCESS ) break;  /* 查询磁盘是否准备好,支持CH375S和CH375A,但占用更多的代码空间 */
  106.                 }

  108. #if DISK_BASE_BUF_LEN
  109.                 if ( DISK_BASE_BUF_LEN < CH375vSectorSize ) {  /* 检查磁盘数据缓冲区是否足够大,CH375vSectorSize是U盘的实际扇区大小 */
  110.                         printf( "Too large sector size\n" );
  111.                         while ( CH375DiskConnect( ) == ERR_SUCCESS ) mDelaymS( 100 );
  112.                         continue;
  113.                 }
  114. #endif
  115. /* 读取原文件 */
  116.                 printf( "Open\n" );
  117.                 mCopyCodeStringToIRAM( mCmdParam.Open.mPathName, "/LCSOFT.TXT" );  /* 文件名,该文件在C51子目录下 */
  118.                 i = CH375FileOpen( );  /* 打开文件 */
  119.                 if ( i == ERR_MISS_DIR || i == ERR_MISS_FILE ) {  /* 没有找到C51子目录,没有找到CH375HFT.C文件 */
  120. /* 列出文件 */
  121.                         if ( i == ERR_MISS_DIR ) pCodeStr = "/*";  /* C51子目录不存在则列出根目录下的所有文件 */
  122.                         else pCodeStr = "/LC*";  /* CH375HFT.C文件不存在则列出\C51子目录下的以CH375开头的文件 */
  123.                         printf( "List file %s\n", pCodeStr );
  124.                         for ( EnumCount = 0; EnumCount < 10000; EnumCount ++ ) {  /* 最多搜索前10000个文件,实际上没有限制 */
  125.                                 i = mCopyCodeStringToIRAM( mCmdParam.Open.mPathName, pCodeStr );  /* 搜索文件名,*为通配符,适用于所有文件或者子目录 */
  126.                                 mCmdParam.Open.mPathName[ i ] = 0xFF;  /* 根据字符串长度将结束符替换为搜索的序号,从0到254,如果是0xFF即255则说明搜索序号在CH375vFileSize变量中 */
  127.                                 CH375vFileSize = EnumCount;  /* 指定搜索/枚举的序号 */
  128.                                 i = CH375FileOpen( );  /* 打开文件,如果文件名中含有通配符*,则为搜索文件而不打开 */
  129. /* CH375FileEnum 与 CH375FileOpen 的唯一区别是当后者返回ERR_FOUND_NAME时那么对应于前者返回ERR_SUCCESS */
  130.                                 if ( i == ERR_MISS_FILE ) break;  /* 再也搜索不到匹配的文件,已经没有匹配的文件名 */
  131.                                 if ( i == ERR_FOUND_NAME ) {  /* 搜索到与通配符相匹配的文件名,文件名及其完整路径在命令缓冲区中 */
  132.                                         printf( "  match file %04d#: %s\n", (unsigned int)EnumCount, mCmdParam.Open.mPathName );  /* 显示序号和搜索到的匹配文件名或者子目录名 */
  133.                                         continue;  /* 继续搜索下一个匹配的文件名,下次搜索时序号会加1 */
  134.                                 }
  135.                                 else {  /* 出错 */
  136.                                         mStopIfError( i );
  137.                                         break;
  138.                                 }
  139.                         }
  140.                 }
  141.                 else {  /* 找到文件或者出错 */
  142.                         mStopIfError( i );
  143.                         TotalCount = CH375vFileSize;  /* 准备读取总长度 */
  144.                         printf( "从文件中读出的前%d个字符是:\n",(UINT16)TotalCount );
  145.                         while ( TotalCount ) {  /* 如果文件比较大,一次读不完,可以再调用CH375ByteRead继续读取,文件指针自动向后移动 */
  146.                                 if ( TotalCount > MAX_BYTE_IO ) c = MAX_BYTE_IO;  /* 剩余数据较多,限制单次读写的长度不能超过 sizeof( mCmdParam.ByteRead.mByteBuffer ) */
  147.                                 else c = TotalCount;  /* 最后剩余的字节数 */
  148.                                 mCmdParam.ByteRead.mByteCount = c;  /* 请求读出几十字节数据 */
  149.                                 i = CH375ByteRead( );  /* 以字节为单位读取数据块,单次读写的长度不能超过MAX_BYTE_IO,第二次调用时接着刚才的向后读 */
  150.                                 mStopIfError( i );
  151.                                 TotalCount -= mCmdParam.ByteRead.mByteCount;  /* 计数,减去当前实际已经读出的字符数 */
  152.                                 for ( i=0; i!=mCmdParam.ByteRead.mByteCount; i++ ) printf( "%C", mCmdParam.ByteRead.mByteBuffer[i] );  /* 显示读出的字符 */
  153.                                 if ( mCmdParam.ByteRead.mByteCount < c ) {  /* 实际读出的字符数少于要求读出的字符数,说明已经到文件的结尾 */
  154.                                         printf( "\n" );
  155.                                         printf( "文件已经结束\n" );
  156.                                         break;
  157.                                 }
  158.                         }
  159. /*            如果希望从指定位置开始读写,可以移动文件指针
  160.                 mCmdParam.ByteLocate.mByteOffset = 608;  跳过文件的前608个字节开始读写
  161.                 CH375ByteLocate( );
  162.                 mCmdParam.ByteRead.mByteCount = 5;  读取5个字节
  163.                 CH375ByteRead( );   直接读取文件的第608个字节到612个字节数据,前608个字节被跳过

  165.             如果希望将新数据添加到原文件的尾部,可以移动文件指针
  166.                 CH375FileOpen( );
  167.                 mCmdParam.ByteLocate.mByteOffset = 0xffffffff;  移到文件的尾部
  168.                 CH375ByteLocate( );
  169.                 mCmdParam.ByteWrite.mByteCount = 13;  写入13个字节的数据
  170.                 CH375ByteWrite( );   在原文件的后面添加数据,新加的13个字节接着原文件的尾部放置
  171.                 mCmdParam.ByteWrite.mByteCount = 2;  写入2个字节的数据
  172.                 CH375ByteWrite( );   继续在原文件的后面添加数据
  173.                 mCmdParam.ByteWrite.mByteCount = 0;  写入0个字节的数据,实际上该操作用于通知程序库更新文件长度
  174.                 CH375ByteWrite( );   写入0字节的数据,用于自动更新文件的长度,所以文件长度增加15,如果不这样做,那么执行CH375FileClose时也会自动更新文件长度
  175. */
  176.                         printf( "Close\n" );
  177.                         i = CH375FileClose( );  /* 关闭文件 */
  178.                         mStopIfError( i );
  179.                 }

  181. #ifdef EN_DISK_WRITE  /* 子程序库支持写操作 */
  182. /* 产生新文件(覆盖原文件数据),关于向原有文件中添加数据的例子请参考EXAM7和EXAM8 */
  183.                 LED_WR_NOW( );  /* 写操作 */
  184.                 printf( "Create\n" );
  185.                 mCopyCodeStringToIRAM( mCmdParam.Create.mPathName, "/LCSOFT.TXT" );  /* 新文件名,在根目录下,中文文件名 */
  186.                 i = CH375FileCreate( );  /* 新建文件并打开,如果文件已经存在则先删除后再新建 */
  187.                 mStopIfError( i );
  188.                 printf( "Write\n" );
  189.                 pCodeStr = "\xd\xa$LC工作室$\xd\xa^O^欢迎你^O^\xd\xa";
  190.                 while( 1 ) {  /* 分多次写入文件数据 */
  191.                         for ( i=0; i<MAX_BYTE_IO; i++ ) {
  192.                                 c = *pCodeStr;
  193.                                 mCmdParam.ByteWrite.mByteBuffer[i] = c;
  194.                                 if ( c == 0 ) break;  /* 源字符串结束 */
  195.                                 pCodeStr++;
  196.                         }
  197.                         if ( i == 0 ) break;  /* 源字符串结束,完成写文件 */
  198.                         mCmdParam.ByteWrite.mByteCount = i;  /* 写入数据的字符数,单次读写的长度不能超过MAX_BYTE_IO,第二次调用时接着刚才的向后写 */
  199.                         i = CH375ByteWrite( );  /* 向文件写入数据 */
  200.                         mStopIfError( i );
  201.                 }
  202.                 printf( "Close\n" );
  203.                 mCmdParam.Close.mUpdateLen = 1;  /* 自动计算文件长度,以字节为单位写文件,建议让程序库关闭文件以便自动更新文件长度 */
  204.                 i = CH375FileClose( );
  205.                 mStopIfError( i );
  206.                 LED_NOT_WR( );
  207. #endif

  209.                 printf( "Take out USB disk\n" );
  210. //                while ( CH375DiskStatus != DISK_DISCONNECT ) xQueryInterrupt( );  /* 查询CH375中断并更新中断状态,等待U盘拔出 */
  211.                 while ( CH375DiskStatus >= DISK_CONNECT ) {  /* 查询CH375中断并更新中断状态,等待U盘拔出 */
  212.                         if ( CH375DiskConnect( ) != ERR_SUCCESS ) break;
  213.                         mDelaymS( 100 );
  214.                 }
  215.                 LED_UDISK_OUT( );  /* LED灭 */
  216.                 mDelaymS( 100 );
  217.         }
  218. }
复制代码
  1. /*
  2. ****************************************
  3. **  Copyright  (C)  W.ch  1999-2005   **
  4. ****************************************
  5. **  KC7.0@MCS51                       **
  6. ****************************************
  7. */
  8. /* CH375评估板演示程序: 演示USB-HOST主机接口和USB-DEVICE设备接口的应用 */
  9. /* MCS-51单片机C语言的示例程序, 适用于89C52或者更大程序空间的单片机,也适用于ATMEL/PHILIPS/SST等具有1KB内部RAM的单片机 */

  11. /* 关于本程序中的CH375主机接口: HOST.C
  12.        可以连接U盘, 支持U盘文件系统FAT12/FAT16/FAT32, 容量不限,
  13.        插入U盘后, 该程序将U盘中的/C51/CH375HFT.C文件中的前600个字符显示出来,
  14.        如果找不到原文件CH375HFT.C, 那么该程序将显示C51子目录下所有以CH375开头的文件名,
  15.        如果找不到C51子目录, 那么该程序将显示根目录下的所有文件名,
  16.        最后将程序ROM中的一个字符串写入写入新建的文件"NEWFILE.TXT"中,
  17.        CH375的INT#引脚采用查询方式处理, 数据复制方式为"单DPTR复制", 兼容性最好但是速度最慢,
  18.        以字节为单位读写U盘文件, 读写速度较扇区模式慢, 不需要文件数据缓冲区FILE_DATA_BUF,
  19.        总共只需要600字节的RAM, 适用于单片机硬件资源有限、数据量小并且读写速度要求不高的系统,
  20.        计算机端可以通过串口监控/调试工具软件以9600bps查看演示情况, 也可以使用CH341的串口工具或者CH375模块的演示工具 */
  21. /* 关于本程序中的CH375设备接口: DEVICE.C
  22.        采用请求+应答模式通讯结构, 强调可靠性和交互性, 不追求传输速度,
  23.        计算机端可以通过CH372/CH375的调试工具中的MCS51监控工具程序CH37XDBG.EXE实现对MCS51单片机的"完全"控制,
  24.        可以读写MCS51单片机的任意外部RAM、内部RAM以及绝大多数SFR, 当然也能够进行数据通讯 */
  25. /* 关于主从切换:
  26.        本程序默认工作于USB-HOST主机方式, 当有USB设备连接时自动处理, 需要作为USB设备与计算机通讯时, 可以按评估板上的按钮由主程序进行切换 */


  29. /* C51   CH375.C */
  30. /* C51   HOST.C */
  31. /* C51   DEVICE.C */
  32. /* LX51  CH375.OBJ, HOST.OBJ, DEVICE.OBJ, CH375HF6.LIB */
  33. /* OHX51 CH375 */


  36. #define                CH375HF_NO_CODE                1
  37. #include "CH375.H"

  39. /* 为printf和getkey输入输出初始化串口 */
  40. void        mInitSTDIO( )
  41. {
  42.         SCON = 0x50;
  43.         //PCON = 0x80;
  44.         TMOD = 0x21;
  45.         TH1 = 0xfd;  /* 11.0592MHz晶振, 9600bps */
  46.         TR1 = 1;
  47.         TI = 1;
  48. }



  52. main( ) {
  53. //        LED_OUT_INIT( );
  54. //        LED_OUT_ACT( );  /* 开机后LED闪烁一下以示工作 */
  55. //        mDelaymS( 100 );  /* 延时100毫秒 */
  56. //        LED_OUT_INACT( );
  57.         mDelaymS( 100 );

  59.         mInitSTDIO( );  /* 为了让计算机通过串口监控演示过程 */
  60.         printf( "Start CH375 demo ...\n" );

  62.         EA = 1;
  63.         LED_OUT_ACT( );  /* LED亮以示工作 */
  64.         while ( 1 ) {  /* 用户按键导致USB主从模式来回切换 */
  65.                 LED_HOST( );
  66.                 printf( "Set USB host mode\n" );
  67.                 host( );
  68.         //        LED_DEVICE( );
  69.         //        printf( "Set USB device mode\n" );
  70.         //        device( );
  71.         }
  72. }
复制代码

AVR_GCC_CH375单片机测试程序：
  1. /*
  2. **  USB Host File Interface for CH375 **
  3. **  TC2.0@PC, WinAVR_GCC_3.45@AVR     **
  4. ****************************************
  5. */
  6. /* CH375 主机文件系统接口 */
  7. /* 支持: FAT12/FAT16/FAT32 */

  9. /* AVR单片机C语言的U盘文件读写示例程序 */
  10. /* 该程序将U盘中的/C51/CH375HFT.C文件中的前600个字符显示出来,
  11.    如果找不到原文件CH375HFT.C, 那么该程序将显示C51子目录下所有以CH375开头的文件名,
  12.    如果找不到C51子目录, 那么该程序将显示根目录下的所有文件名,
  13.    最后将程序ROM中的一个字符串写入写入新建的文件"NEWFILE.TXT"中
  14. */
  15. /* CH375的INT#引脚采用查询方式处理, 数据复制方式为"内部复制", 本程序适用于ATmega128单片机, 串口0输出监控信息,9600bps */
  16. /* 本例以字节为单位读写U盘文件,读写速度较扇区模式慢,但是由于字节模式读写文件不需要文件数据缓冲区FILE_DATA_BUF,
  17.    所以总共只需要600字节的RAM,适用于单片机硬件资源有限、数据量小并且读写速度要求不高的系统 */

  19. /* AVR-GCC -v -mmcu=atmega128 -O2 -xc CH375HFT.c -oCH375HFT.ELF -lCH375HFD */
  20. /* AVR-OBJCOPY -j .text -j .data -O ihex CH375HFT.ELF CH375HFT.HEX */

  22. #include <string.h>
  23. #include <stdio.h>
  24. #define         F_CPU        7372800                /* 单片机主频为16MHz,用于延时子程序 */
  25. #include <util/delay.h>
  26. #include <avr/io.h>



  30. #include<avr/eeprom.h>

  32. #include<avr/pgmspace.h>

  34. #define FOSC   F_CPU
  35. #define F_CPU  7372800
  36. //#define BAUD   115200
  37. #define BAUD   9600

  39. #define MYUBRR FOSC/BAUD/16-1


  42. int USART_putchar(char CH)
  43. {
  44.         /* Wait for empty transmit buffer */
  45.         while ( !( UCSR0A & (1<<UDRE0)) );
  46.         /* Put data into buffer, sends the data */
  47.         UDR0=CH;
  48.         return 0;
  49. }


  52. int USART_getchar(void)
  53. {
  54.          /* Wait for data to be received */
  55.         while ( !(UCSR0A & (1<<RXC0)) );
  56.         /* Get and return received data from buffer */
  57.         return UDR0;
  58. }


  61. void COM_Initial(unsigned int UBRR_val)
  62. {
  63.         /* Set baud rate */
  64.         UBRR0H = (unsigned char)(UBRR_val>>8);
  65.         UBRR0L = (unsigned char)UBRR_val;
  66.         /* Enable receiver and transmitter */
  67.         UCSR0B = (1<<RXEN0)|(1<<TXEN0);
  68.         /* Set frame format: 8data, 2stop bit */
  69.         //UCSRC = (1<<URSEL)|(1<<USBS)|(3<<UCSZ0);
  70.         fdevopen(USART_putchar,USART_getchar);//
  71. }



  75. /* 以下定义的详细说明请看CH375HF9.H文件 */
  76. #define LIB_CFG_FILE_IO                        1                /* 文件读写的数据的复制方式,0为"外部子程序",1为"内部复制" */
  77. #define LIB_CFG_INT_EN                        0                /* CH375的INT#引脚连接方式,0为"查询方式",1为"中断方式" */

  79. #define DISK_BASE_BUF_LEN                2048        /* 默认的磁盘数据缓冲区大小为512字节,建议选择为2048甚至4096以支持某些大扇区的U盘,为0则禁止在.H文件中定义缓冲区并由应用程序在pDISK_BASE_BUF中指定 */
  80. /* 单片机的RAM有限,其中CH375子程序用512字节,剩余RAM部分可以用于文件读写缓冲 */
  81. #define FILE_DATA_BUF_LEN                0x0200        /* 外部RAM的文件数据缓冲区,缓冲区长度不小于一次读写的数据长度 */

  83. #define CH375_INT_WIRE                        ( PING & 0x01 )        /* PINB.4, CH375的中断线INT#引脚,连接CH375的INT#引脚,用于查询中断状态 */

  85. #define NO_DEFAULT_CH375_F_ENUM                1                /* 未调用CH375FileEnumer程序故禁止以节约代码 */
  86. #define NO_DEFAULT_CH375_F_QUERY        1                /* 未调用CH375FileQuery程序故禁止以节约代码 */

  88. #include "..\CH375HFD.H"

  90. /* 有些AVR单片机提供开放系统总线,那么直接将CH375挂在其系统总线上,以8位I/O方式进行读写 */
  91. /* 虽然Atmega128提供系统总线,不过本例假定不开放系统总线,所以用I/O引脚模拟产生CH375的并口读写时序 */
  92. /* 本例中的硬件连接方式如下(实际应用电路可以参照修改下述3个并口读写子程序) */
  93. /*    单片机的引脚     CH375芯片的引脚
  94.        PINB.4                INT#
  95.        PORTB.3               A0
  96.        PORTB.2               CS#
  97.        PORTB.1               WR#
  98.        PORTB.0               RD#
  99.       PORTD(8位端口)        D7-D0       */

  101. #define CH375_INT                        0

  103. #define CH375_AO                        1
  104. #define CH375_CS                        2
  105. #define CH375_WR                        4
  106. #define CH375_RD                        3         


  109. //#ifdef F_CPU
  110. //// 使用系统delay.h中提供函数
  111. //#define        mDelay1uS( )        _delay_us(1)
  112. //#else





  118. void mDelay1uS( )  /* 至少延时1uS,根据单片机主频调整 */
  119. {
  120. //        UINT16        i;
  121. //        for ( i = 5; i != 0; i -- );
  122. // 以上代码会被优化掉，所以用嵌入式汇编
  123.         UINT8        count = 2;  /* 延时1uS,3x50nS@20MHz */
  124.         __asm__ volatile (
  125.                 "1: dec %0" "\n\t"
  126.                 "brne 1b"
  127.                 : "=r" (count)
  128.                 : "0" (count)
  129.         );
  130. }
  131. //#endif

  133. void CH375_PORT_INIT( )  /* 由于使用通用I/O模块并口读写时序,所以进行初始化 */
  134. {
  135.         DDRD = 0x00;  /* 设置8位并口为输入 */
  136.         //PORTB = 0x07;  /* 设置CS,WR,RD默认为高电平 */
  137.         PORTG |= (0x01 << CH375_CS);
  138.         PORTG |= (0x01 << CH375_WR);
  139.         PORTG |= (0x01 << CH375_RD);
  140.         DDRG = 0x1e;  
  141. //        DDRB = 0x0F;  /* 设置CS,WR,RD,A0为输出,设置INT#为输入 */
  142. }

  144. void xWriteCH375Cmd( UINT8 mCmd )                /* 外部定义的被CH375程序库调用的子程序,向CH375写命令 */
  145. {
  146.         mDelay1uS( ); mDelay1uS( );  /* 至少延时1uS */
  147. /*        *(volatile unsigned char *)CH375_CMD_PORT_ADDR = mCmd;  通过并口直接读写CH375而非普通I/O模拟 */
  148.         //PORTB |= 0x08;  /* 输出A0=1 */
  149.         PORTG |= (0x01 << CH375_AO);
  150.         
  151.         PORTD = mCmd;  /* 向CH375的并口输出数据 */
  152.         DDRD = 0xFF;  /* 并口D0-D7输出 */
  153.         
  154.         //PORTB &= 0xF9;  /* 输出有效写控制信号, 写CH375芯片的命令端口, A0=1; CS=0; WR=0; RD=1; */
  155.         PORTG &= ~(0x01 << CH375_CS);
  156.         PORTG &= ~(0x01 << CH375_WR);
  157.         DDRD = 0xFF;  /* 该操作无意义,仅作延时,CH375要求读写脉冲宽度大于100nS */
  158.         
  159.         //PORTB |= 0x07;  /* 输出无效的控制信号, 完成操作CH375芯片, A0=1; CS=1; WR=1; RD=1; */
  160.         PORTG |= (0x01 << CH375_CS);
  161.         PORTG |= (0x01 << CH375_WR);
  162.         PORTG |= (0x01 << CH375_RD);
  163.         
  164.         DDRD = 0x00;  /* 禁止数据输出 */
  165.         
  166.         //PORTB &= 0xF7;  /* 输出A0=0; 可选操作 */
  167.         PORTG &= ~(0x01 << CH375_AO);
  168.         mDelay1uS( ); mDelay1uS( );  /* 至少延时2uS */
  169. }

  171. void xWriteCH375Data( UINT8 mData )                /* 外部定义的被CH375程序库调用的子程序,向CH375写数据 */
  172. {
  173. /*        *(volatile unsigned char *)CH375_DAT_PORT_ADDR = mData;  通过并口直接读写CH375而非普通I/O模拟 */
  174.         PORTD = mData;  /* 向CH375的并口输出数据 */
  175.         DDRD = 0xFF;  /* 并口D0-D7输出 */
  176.         //PORTB &= 0xF1;  /* 输出有效写控制信号, 写CH375芯片的数据端口, A0=0; CS=0; WR=0; RD=1; */
  177.         PORTG &= ~(0x01 << CH375_AO);
  178.         PORTG &= ~(0x01 << CH375_CS);
  179.         PORTG &= ~(0x01 << CH375_WR);
  180.         
  181.         DDRD = 0xFF;  /* 该操作无意义,仅作延时,CH375要求读写脉冲宽度大于100nS */
  182.         //PORTB |= 0x07;  /* 输出无效的控制信号, 完成操作CH375芯片, A0=0; CS=1; WR=1; RD=1; */
  183.         PORTG |= (0x01 << CH375_CS);
  184.         PORTG |= (0x01 << CH375_WR);
  185.         PORTG |= (0x01 << CH375_RD);
  186.         
  187.         DDRD = 0x00;  /* 禁止数据输出 */
  188.         mDelay1uS( );  /* 至少延时1.2uS */
  189. }

  191. UINT8 xReadCH375Data( void )                        /* 外部定义的被CH375程序库调用的子程序,从CH375读数据 */
  192. {
  193.         UINT8        mData;
  194. /*        mData = *(volatile unsigned char *)CH375_DAT_PORT_ADDR;  通过并口直接读写CH375而非普通I/O模拟 */
  195.         mDelay1uS( );  /* 至少延时1.2uS */
  196.         DDRD = 0x00;  /* 数据输入 */
  197.         //PORTB &= 0xF2;  /* 输出有效读控制信号, 读CH375芯片的数据端口, A0=0; CS=0; WR=1; RD=0; */
  198.         PORTG &= ~(0x01 << CH375_AO);
  199.         PORTG &= ~(0x01 << CH375_CS);
  200.         PORTG &= ~(0x01 << CH375_RD);
  201.         DDRD = 0x00;  /* 该操作无意义,仅作延时,CH375要求读写脉冲宽度大于100nS */
  202.         mData = PIND;  /* 从CH375的并口PA输入数据 */
  203.         //PORTB |= 0x07;  /* 输出无效的控制信号, 完成操作CH375芯片, A0=0; CS=1; WR=1; RD=1; */
  204.                 PORTG |= (0x01 << CH375_CS);
  205.         PORTG |= (0x01 << CH375_WR);
  206.         PORTG |= (0x01 << CH375_RD);
  207.         
  208.         return( mData );
  209. }

  211. /* 在P0.2连接一个LED用于监控演示程序的进度,低电平LED亮 */
  212. #define LED_OUT_INIT( )                { PORTC |= 0x01; DDRC |= 0x01; }        /* PORTG.7 高电平为输出方向 */
  213. #define LED_OUT_ACT( )                { PORTC &= 0xfe; }        /* PORTG.7 低电平驱动LED显示 */
  214. #define LED_OUT_INACT( )        { PORTC |= 0x01; }        /* PORTG.7 低电平驱动LED显示 */

  216. /* 延时指定毫秒时间,根据单片机主频调整,不精确 */
  217. void        mDelaymS( UINT8 ms )
  218. {
  219.         UINT16        i;
  220.         while ( ms -- ) for ( i = 1000; i != 0; i -- ) mDelay1uS( );
  221. }

  223. /* 检查操作状态,如果错误则显示错误代码并停机 */
  224. void        mStopIfError( UINT8 iError )
  225. {
  226.         if ( iError == ERR_SUCCESS ) return;  /* 操作成功 */
  227.         printf_P(PSTR("\r\n************************************************"));
  228.         printf_P(PSTR("\r\nError: %02X\n"), (UINT16)iError);  /* 显示错误 */
  229.         
  230.         while ( 1 ) {
  231.                 LED_OUT_ACT( );  /* LED闪烁 */
  232.                 mDelaymS( 100 );
  233.                 LED_OUT_INACT( );
  234.                 mDelaymS( 100 );
  235.         }
  236. }

  238. //FILE        uart_str = FDEV_SETUP_STREAM( uart_putchar, NULL, _FDEV_SETUP_WRITE );




  243. int                main( )
  244. {
  245.         UINT8        i, c;
  246.         UINT16        TotalCount;
  247.         UINT8        *pCodeStr;

  249. //        mInitSTDIO();  /* 为了让计算机通过串口监控演示过程 */

  251.         COM_Initial(MYUBRR);//初始化串口

  253.         

  255.         printf_P(PSTR("Lcsoft 2010 (C)\n" ));
  256.         printf_P(PSTR("Start\n" ));

  258.         CH375_PORT_INIT( );
  259.         LED_OUT_INIT( );
  260.         LED_OUT_ACT( );  /* 开机后LED亮一下以示工作 */
  261.         //mDelaymS( 100 );  /* 延时100毫秒 */
  262. //        LED_OUT_INACT( );

  264. #if DISK_BASE_BUF_LEN == 0
  265.         pDISK_BASE_BUF = &my_buffer[0];  /* 不在.H文件中定义CH375的专用缓冲区,而是用缓冲区指针指向其它应用程序的缓冲区便于合用以节约RAM */
  266. #endif

  268.         i = CH375LibInit( );  /* 初始化CH375程序库和CH375芯片,操作成功返回0 */
  269.         mStopIfError( i );
  270. /* 其它电路初始化 */

  272.         while ( 1 ) {
  273.                 printf_P(PSTR("Wait Udisk\n" ));
  274. //                while ( CH375DiskStatus != DISK_CONNECT ) xQueryInterrupt( );  /* 查询CH375中断并更新中断状态,等待U盘插入 */
  275.                 while ( CH375DiskStatus < DISK_CONNECT ) {  /* 查询CH375中断并更新中断状态,等待U盘插入 */
  276.                         if ( CH375DiskConnect( ) == ERR_SUCCESS ) break;  /* 有设备连接则返回成功,CH375DiskConnect同时会更新全局变量CH375DiskStatus */
  277.                         mDelaymS( 100 );
  278.                 }
  279.                 LED_OUT_ACT( );  /* LED亮 */
  280.                 mDelaymS( 200 );  /* 延时,可选操作,有的USB存储器需要几十毫秒的延时 */

  282. /* 检查U盘是否准备好,有些U盘不需要这一步,但是某些U盘必须要执行这一步才能工作 */
  283.                 for ( i = 0; i < 10; i ++ ) {  /* 有的U盘总是返回未准备好,不过可以被忽略 */
  284.                         mDelaymS( 100 );
  285.                         printf_P(PSTR("Ready ?\n" ));
  286.                         if ( CH375DiskReady( ) == ERR_SUCCESS ) break;  /* 查询磁盘是否准备好 */
  287.                 }
  288. #if DISK_BASE_BUF_LEN
  289.                 if ( DISK_BASE_BUF_LEN < CH375vSectorSize ) {  /* 检查磁盘数据缓冲区是否足够大,CH375vSectorSize是U盘的实际扇区大小 */
  290.                         printf_P(PSTR("Too large sector size\n" ));
  291.                         while ( CH375DiskConnect( ) == ERR_SUCCESS ) mDelaymS( 100 );
  292.                         continue;
  293.                 }
  294. #endif
  295. /* 查询磁盘物理容量 */
  296. /*                printf_P(PSTR("DiskSize\n" );
  297.                 i = CH375DiskSize( );  
  298.                 mStopIfError( i );
  299.                 printf_P(PSTR("TotalSize = %u MB \n", (unsigned int)( mCmdParam.DiskSize.mDiskSizeSec * (CH375vSectorSize/512) / 2048 ) );  // 显示为以MB为单位的容量
  300.                 // 原计算方法 (unsigned int)( mCmdParam.DiskSize.mDiskSizeSec * CH375vSectorSize / 1000000 ) 有可能前两个数据相乘后导致溢出, 所以修改成上式
  301. */

  303. /* 读取原文件 */
  304.                 printf_P(PSTR("Open\n" ));
  305.                 strcpy( (char *)mCmdParam.Open.mPathName, "/C51/CH375HFT.C" );  /* 文件名,该文件在C51子目录下 */
  306.                 i = CH375FileOpen( );  /* 打开文件 */
  307.                 if ( i == ERR_MISS_DIR || i == ERR_MISS_FILE ) {  /* 没有找到文件 */
  308. /* 列出文件 */
  309.                         if ( i == ERR_MISS_DIR ) pCodeStr = (UINT8 *)"/*";  /* C51子目录不存在则列出根目录下的文件 */
  310.                         else pCodeStr = (UINT8 *)"/C51/CH375*";  /* CH375HFT.C文件不存在则列出\C51子目录下的以CH375开头的文件 */
  311.                         printf_P(PSTR("List file %s\n"), pCodeStr );
  312.                         for ( c = 0; c < 254; c ++ ) {  /* 最多搜索前254个文件 */
  313.                                 strcpy( (char *)mCmdParam.Open.mPathName, (char *)pCodeStr );  /* 搜索文件名,*为通配符,适用于所有文件或者子目录 */
  314.                                 i = strlen( (char *)mCmdParam.Open.mPathName );  /* 计算文件名长度,以处理文件名结束符 */
  315.                                 mCmdParam.Open.mPathName[ i ] = c;  /* 根据字符串长度将结束符替换为搜索的序号,从0到255 */
  316.                                 i = CH375FileOpen( );  /* 打开文件,如果文件名中含有通配符*,则为搜索文件而不打开 */
  317.                                 if ( i == ERR_MISS_FILE ) break;  /* 再也搜索不到匹配的文件,已经没有匹配的文件名 */
  318.                                 if ( i == ERR_FOUND_NAME ) {  /* 搜索到与通配符相匹配的文件名,文件名及其完整路径在命令缓冲区中 */
  319.                                         printf_P(PSTR("  match file %03d#: %s\n"), (unsigned int)c, mCmdParam.Open.mPathName );  /* 显示序号和搜索到的匹配文件名或者子目录名 */
  320.                                         continue;  /* 继续搜索下一个匹配的文件名,下次搜索时序号会加1 */
  321.                                 }
  322.                                 else {  /* 出错 */
  323.                                         mStopIfError( i );
  324.                                         break;
  325.                                 }
  326.                         }
  327.                 }
  328.                 else {  /* 找到文件或者出错 */
  329.                         mStopIfError( i );
  330.                         TotalCount = 600;  /* 准备读取总长度 */
  331.                         printf_P(PSTR("从文件中读出的前%d个字符是:\n"),TotalCount );
  332.                         while ( TotalCount ) {  /* 如果文件比较大,一次读不完,可以再调用CH375ByteRead继续读取,文件指针自动向后移动 */
  333.                                 if ( TotalCount > MAX_BYTE_IO ) c = MAX_BYTE_IO;  /* 剩余数据较多,限制单次读写的长度不能超过 sizeof( mCmdParam.ByteRead.mByteBuffer ) */
  334.                                 else c = TotalCount;  /* 最后剩余的字节数 */
  335.                                 mCmdParam.ByteRead.mByteCount = c;  /* 请求读出几十字节数据 */
  336.                                 i = CH375ByteRead( );  /* 以字节为单位读取数据块,单次读写的长度不能超过MAX_BYTE_IO,第二次调用时接着刚才的向后读 */
  337.                                 mStopIfError( i );
  338.                                 TotalCount -= mCmdParam.ByteRead.mByteCount;  /* 计数,减去当前实际已经读出的字符数 */
  339.                                 for ( i=0; i!=mCmdParam.ByteRead.mByteCount; i++ ) printf_P(PSTR("%c"), mCmdParam.ByteRead.mByteBuffer[i] );  /* 显示读出的字符 */
  340.                                 if ( mCmdParam.ByteRead.mByteCount < c ) {  /* 实际读出的字符数少于要求读出的字符数,说明已经到文件的结尾 */
  341.                                         printf_P(PSTR("\n" ));
  342.                                         printf_P(PSTR("文件已经结束\n" ));
  343.                                         break;
  344.                                 }
  345.                         }
  346. /*            如果希望从指定位置开始读写,可以移动文件指针
  347.                 mCmdParam.ByteLocate.mByteOffset = 608;  跳过文件的前608个字节开始读写
  348.                 CH375ByteLocate( );
  349.                 mCmdParam.ByteRead.mByteCount = 5;  读取5个字节
  350.                 CH375ByteRead( );   直接读取文件的第608个字节到612个字节数据,前608个字节被跳过

  352.             如果希望将新数据添加到原文件的尾部,可以移动文件指针
  353.                 CH375FileOpen( );
  354.                 mCmdParam.ByteLocate.mByteOffset = 0xffffffff;  移到文件的尾部
  355.                 CH375ByteLocate( );
  356.                 mCmdParam.ByteWrite.mByteCount = 13;  写入13个字节的数据
  357.                 CH375ByteWrite( );   在原文件的后面添加数据,新加的13个字节接着原文件的尾部放置
  358.                 mCmdParam.ByteWrite.mByteCount = 2;  写入2个字节的数据
  359.                 CH375ByteWrite( );   继续在原文件的后面添加数据
  360.                 mCmdParam.ByteWrite.mByteCount = 0;  写入0个字节的数据,实际上该操作用于通知程序库更新文件长度
  361.                 CH375ByteWrite( );   写入0字节的数据,用于自动更新文件的长度,所以文件长度增加15,如果不这样做,那么执行CH375FileClose时也会自动更新文件长度
  362. */
  363.                         printf_P(PSTR("Close\n" ));
  364.                         i = CH375FileClose( );  /* 关闭文件 */
  365.                         mStopIfError( i );
  366.                 }

  368. #ifdef EN_DISK_WRITE  /* 子程序库支持写操作 */
  369. /* 产生新文件 */
  370.                 printf_P(PSTR("Create\n" ));
  371.                 strcpy( (char *)mCmdParam.Create.mPathName, "/NEWFILE.TXT" );  /* 新文件名,在根目录下,中文文件名 */
  372.                 i = CH375FileCreate( );  /* 新建文件并打开,如果文件已经存在则先删除后再新建 */
  373.                 mStopIfError( i );
  374.                 printf_P(PSTR("Write\n" ));
  375.                 pCodeStr = (UINT8 *)"Note: \xd\xa这个程序是以字节为单位进行U盘文件读写,单片机只需要有600字节的RAM\xd\xa";
  376.                 while( 1 ) {  /* 分多次写入文件数据 */
  377.                         for ( i=0; i<MAX_BYTE_IO; i++ ) {
  378.                                 c = *pCodeStr;
  379.                                 mCmdParam.ByteWrite.mByteBuffer[i] = c;
  380.                                 if ( c == 0 ) break;  /* 源字符串结束 */
  381.                                 pCodeStr++;
  382.                         }
  383.                         if ( i == 0 ) break;  /* 源字符串结束,完成写文件 */
  384.                         mCmdParam.ByteWrite.mByteCount = i;  /* 写入数据的字符数,单次读写的长度不能超过MAX_BYTE_IO,第二次调用时接着刚才的向后写 */
  385.                         i = CH375ByteWrite( );  /* 向文件写入数据 */
  386.                         mStopIfError( i );
  387.                 }
  388. /*                printf_P(PSTR("Modify\n" );
  389.                 mCmdParam.Modify.mFileAttr = 0xff;   输入参数: 新的文件属性,为0FFH则不修改
  390.                 mCmdParam.Modify.mFileTime = 0xffff;   输入参数: 新的文件时间,为0FFFFH则不修改,使用新建文件产生的默认时间
  391.                 mCmdParam.Modify.mFileDate = MAKE_FILE_DATE( 2004, 5, 18 );  输入参数: 新的文件日期: 2004.05.18
  392.                 mCmdParam.Modify.mFileSize = 0xffffffff;   输入参数: 新的文件长度,以字节为单位写文件应该由程序库关闭文件时自动更新长度,所以此处不修改
  393.                 i = CH375FileModify( );   修改当前文件的信息,修改日期
  394.                 mStopIfError( i );
  395. */
  396.                 printf_P(PSTR("Close\n" ));
  397.                 mCmdParam.Close.mUpdateLen = 1;  /* 自动计算文件长度,以字节为单位写文件,建议让程序库关闭文件以便自动更新文件长度 */
  398.                 i = CH375FileClose( );
  399.                 mStopIfError( i );

  401. /* 删除某文件 */
  402. /*                printf_P(PSTR("Erase\n" ));
  403.                 strcpy( (char *)mCmdParam.Create.mPathName, "/OLD" );  将被删除的文件名,在根目录下
  404.                 i = CH375FileErase( );  删除文件并关闭
  405.                 if ( i != ERR_SUCCESS ) printf_P(PSTR("Error: %02X\n", (UINT16)i );  显示错误
  406. */

  408. /* 查询磁盘信息 */
  409. /*                printf_P(PSTR("Disk\n" );
  410.                 i = CH375DiskQuery( );
  411.                 mStopIfError( i );
  412.                 printf_P(PSTR("Fat=%d, Total=%ld, Free=%ld\n", (UINT16)mCmdParam.Query.mDiskFat, mCmdParam.Query.mTotalSector, mCmdParam.Query.mFreeSector );
  413. */
  414. #endif
  415.                 printf_P(PSTR("Take out\n" ));
  416. //                while ( CH375DiskStatus != DISK_DISCONNECT ) xQueryInterrupt( );  /* 查询CH375中断并更新中断状态,等待U盘拔出 */
  417.                 while ( CH375DiskStatus >= DISK_CONNECT ) {  /* 查询CH375中断并更新中断状态,等待U盘拔出 */
  418.                         if ( CH375DiskConnect( ) != ERR_SUCCESS ) break;
  419.                         mDelaymS( 100 );
  420.                 }
  421.                 LED_OUT_INACT( );  /* LED灭 */
  422.                 mDelaymS( 200 );
  423. /*                i = FILE_DATA_BUF[0];  因为是以字节为单位读写文件,未用到文件数据缓冲区,为了防止编译器优化掉该缓冲区而用一下缓冲区 */
  424.         }
  425. }
复制代码

所有资料51hei提供下载:
单片机读取SD资料.zip (11.46 MB, 下载次数: 92)


作者: zjczm    时间: 2019-4-29 17:19
谢谢。学习一下。
作者: hzwdyx    时间: 2019-8-23 00:05
非常受用，帖子真心不错，感谢感谢



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1