返回列表 发新帖我要提问本帖赏金: 20.00元(功能说明)

[STM32F1] 【STM32F103】神操作--如何快速读写内部flash?

[复制链接]
30028|10
 楼主| binoo7 发表于 2021-9-17 13:24 | 显示全部楼层 |阅读模式
本帖最后由 binoo7 于 2021-9-18 15:06 编辑

#申请原创# @21小跑堂@21小跑堂@21小跑堂
大家好,今天和大家分享一下STM32F103C8T6读写内部flash,关于103系列的单片机大家可以参考选项手册查看flash的容量


一、芯片FLASH容量分类:
41361440ec9a2e18.png



可以看到我们今天介绍的这款芯片的flash大小是64K的,网上也有人说它可以支持到128K,但是官方给出的解释是前64K是有保证的,后面的无法保证,所以想要使用的小伙伴需要慎重。
现在芯片的flash大小我们知道了,下面就可以看看这个flash是怎么划分的了,通过芯片数据手册,我们能看到今天说的STM32F103C8T6是属于中等容量的设备。
68387614418f7d881c.png
既然是中等容量的设备了,那我们就来看看flash划分吧,在STM32的闪存编程手册中有这样一段话:按照不同容量,
存储器组织成:
32个1K字节/页(小容量)
128个1K字节/页(中容量)
256个2K字节/页(大容量)
这段话怎么理解呢,就是告诉我们小容量的设备(内存是6K和32K)的设备是由1K字节每页组成的,
中容量的设备(内存是64K和128K)的设备是由1K字节每页组成的,
大容量的设备(内存是256K、384K和512K)的设备是由2K字节每页组成的,
举个例子吧:
一个芯片的存储容量是64K,这64K是什么呢,就是64*1024个BYTE,一个BYTE是由8位0或1组成的,(比如0000 1111 这8个二进制数组成了一个字节,用十进制来说就是15)
小结一下:64K的flash可以存储64*1024个字节的数据。
咱们继续说,这64K的数据怎么划分,存储是按照页为单位进行存储的,一页1K的容量,也就说一页可以存储1024个字节
一共是多少页?
答案是:64页,我们看一下官方是不是这么说的
7820861441db08bc2d.png
在闪存编程手册里确实是这么说的,所以我们刚才说是64页是正确的
二、 读写步骤:
上面我们知道了芯片是怎么分类的,下面我们就重点来讲解一下芯片是怎么读写的。
内部flash我们参照HAL库或者标准库,直接调用ST公司给我们封装好的库进行编程就可以了,这里我用的是标准库,有兴趣的小伙伴可以去看看HAL库
是不是有小伙伴会疑问什么是标准库,什么是HAL库?
在这里给大家解释一下,这两个库都是ST公司,直接把寄存器封装成函数,供大家直接调用某一个函数,就可以完成各种寄存器的配置,不容大家直面芯片的寄存器,方便阅读和使用,因为每个函数的名称功能都是不一样的,在调用前可以参考函数的注释,在F0和F4的标准库里甚至有每个函数的用法,不知道为什么在F1的库里把使用步骤去掉了。
咱们继续,读写的话库函数分为:
  1. /*------------ Functions used for all STM32F10x devices -----*/
  2. void FLASH_SetLatency(uint32_t FLASH_Latency);
  3. void FLASH_HalfCycleAccessCmd(uint32_t FLASH_HalfCycleAccess);
  4. void FLASH_PrefetchBufferCmd(uint32_t FLASH_PrefetchBuffer);
  5. void FLASH_Unlock(void);
  6. void FLASH_Lock(void);
  7. FLASH_Status FLASH_ErasePage(uint32_t Page_Address);
  8. FLASH_Status FLASH_EraseAllPages(void);
  9. FLASH_Status FLASH_EraseOptionBytes(void);
  10. FLASH_Status FLASH_ProgramWord(uint32_t Address, uint32_t Data);
  11. FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data);
  12. FLASH_Status FLASH_ProgramOptionByteData(uint32_t Address, uint8_t Data);
  13. FLASH_Status FLASH_EnableWriteProtection(uint32_t FLASH_Pages);
  14. FLASH_Status FLASH_ReadOutProtection(FunctionalState NewState);
  15. FLASH_Status FLASH_UserOptionByteConfig(uint16_t OB_IWDG, uint16_t OB_STOP, uint16_t OB_STDBY);
  16. uint32_t FLASH_GetUserOptionByte(void);
  17. uint32_t FLASH_GetWriteProtectionOptionByte(void);
  18. FlagStatus FLASH_GetReadOutProtectionStatus(void);
  19. FlagStatus FLASH_GetPrefetchBufferStatus(void);
  20. void FLASH_ITConfig(uint32_t FLASH_IT, FunctionalState NewState);
  21. FlagStatus FLASH_GetFlagStatus(uint32_t FLASH_FLAG);
  22. void FLASH_ClearFlag(uint32_t FLASH_FLAG);
  23. FLASH_Status FLASH_GetStatus(void);
  24. FLASH_Status FLASH_WaitForLastOperation(uint32_t Timeout);

  25. /*------------ New function used for all STM32F10x devices -----*/
  26. void FLASH_UnlockBank1(void);
  27. void FLASH_LockBank1(void);
  28. FLASH_Status FLASH_EraseAllBank1Pages(void);
  29. FLASH_Status FLASH_GetBank1Status(void);
  30. FLASH_Status FLASH_WaitForLastBank1Operation(uint32_t Timeout);
在这里就不一个一个的详细说了,我们说一下常用的就行
1. 解锁
  1. void FLASH_Unlock(void);

2. 上锁
  1. void FLASH_Lock(void);

3. 页擦除
  1. FLASH_Status FLASH_ErasePage(uint32_t Page_Address);

4. 半字写入
  1. FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data);

上面这4个函数就是我们最常用的。
下面说一下数据写入的步骤,
第一步:解锁
第二步:判断写入的数据是否被擦除过,也就是判断写入的地址内存放的是不是0xFFFF 这里要重点说一下,为什么要判断是不是0xFFFF而不是判断是不是0xFF呢?因为我们每次写入数据都要写入半字,也就是两个字节的数据才行,而且写入的地址只能是2的整数倍,不能是奇数。这里大家注意一下。
第三步:写入数据 STM32F103C8T6只能按照半字的方式进行数据写入,写入前的数据必须是0XFFFF,因为FLASH数据写入,只能写0,不能写1,这也就是为什么我们要先确保写入前的数据是被擦除了的原因。
第四步:上锁
第五步:验证写入是否正确
其实第五步可以省略。
我们看看官方给的写入过程

28736144220ebf56d.png
好了,其实是一样的。
下面我就和大家来分享一下(百分之九十九参考的正点原子的例程)

  1. //不检查的写入
  2. //WriteAddr:起始地址
  3. //pBuffer:数据指针
  4. //NumToWrite:半字(16位)数   
  5. void STMFLASH_Write_NoCheck(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)   
  6. {                                          
  7.         u16 i;
  8.         for(i=0;i<NumToWrite;i++)
  9.         {
  10.                 FLASH_ProgramHalfWord(WriteAddr,pBuffer);
  11.             WriteAddr+=2;//地址增加2.
  12.         }  
  13. }
  1. //从指定地址开始写入指定长度的数据
  2. //WriteAddr:起始地址(此地址必须为2的倍数!!)
  3. //pBuffer:数据指针
  4. //NumToWrite:半字(16位)数(就是要写入的16位数据的个数.)

  5. u16 STMFLASH_BUF[STM_SECTOR_SIZE/2];//最多是2K字节
  6. void STMFLASH_Write(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)        
  7. {
  8.         u32 secpos;           //扇区地址
  9.         u16 secoff;           //扇区内偏移地址(16位字计算)
  10.         u16 secremain; //扇区内剩余地址(16位字计算)           
  11.          u16 i;   
  12.         u32 offaddr;   //去掉0X08000000后的地址
  13.         if(WriteAddr<STM32_FLASH_BASE||(WriteAddr>=(STM32_FLASH_BASE+1024*STM32_FLASH_SIZE)))return;//非法地址
  14.         FLASH_Unlock();                                                //解锁
  15.         offaddr=WriteAddr-STM32_FLASH_BASE;                //实际偏移地址.
  16.         secpos=offaddr/STM_SECTOR_SIZE;                        //扇区地址  0~127 for STM32F103RBT6
  17.         secoff=(offaddr%STM_SECTOR_SIZE)/2;                //在扇区内的偏移(2个字节为基本单位.)
  18.         secremain=STM_SECTOR_SIZE/2-secoff;                //扇区剩余空间大小   
  19.         if(NumToWrite<=secremain)
  20.         {
  21.           secremain=NumToWrite;//不大于该扇区范围
  22.         }
  23.         while(1)
  24.         {        
  25.                 STMFLASH_Read(((secpos*STM_SECTOR_SIZE)+STM32_FLASH_BASE),STMFLASH_BUF,STM_SECTOR_SIZE/2);//读出整个扇区的内容
  26.                 for(i=0;i<secremain;i++)//校验数据
  27. //                for(i=0;i<(STM_SECTOR_SIZE/2);i++)//校验数据
  28.                 {
  29.                         if(STMFLASH_BUF[secoff+i]!=0XFFFF)break;//需要擦除  
  30. //        if(STMFLASH_BUF!=0XFFFF)break;//需要擦除                        
  31.                 }
  32.                 FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
  33.                 if(i<secremain)//需要擦除
  34. //                if(i<(STM_SECTOR_SIZE/2))//需要擦除
  35.                 {
  36.                         FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);

  37.                         FLASH_ErasePage(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE);//擦除这个扇区
  38.                         for(i=0;i<secremain;i++)//复制
  39.                         {
  40.                                 STMFLASH_BUF[i+secoff]=pBuffer;         
  41.                         }
  42.                         STMFLASH_Write_NoCheck(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE,STMFLASH_BUF,STM_SECTOR_SIZE/2);//写入整个扇区  
  43.                 }else STMFLASH_Write_NoCheck(WriteAddr,pBuffer,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
  44.                 if(NumToWrite==secremain)break;//写入结束了
  45.                 else//写入未结束
  46.                 {
  47.                                 secpos++;                                //扇区地址增1
  48.                                 secoff=0;                                //偏移位置为0         
  49.                                   pBuffer+=secremain;          //指针偏移
  50.                                 WriteAddr+=(secremain*2);        //写地址偏移           
  51.                                  NumToWrite-=secremain;        //字节(16位)数递减
  52.                                 if(NumToWrite>(STM_SECTOR_SIZE/2))
  53.                                 {
  54.                                   secremain=STM_SECTOR_SIZE/2;//下一个扇区还是写不完
  55.                                 }
  56.                                 else
  57.                                 {
  58.                                   secremain=NumToWrite;//下一个扇区可以写完了
  59.                                 }
  60.                 }         
  61.         }        
  62.         FLASH_Lock();//上锁
  63. }


最终我们调用STMFLASH_Write()函数进行数据的写入,是不是有没看懂的小伙伴,我给大家解释一下写入的过程吧

这个STMFLASH_Write()函数,是说给定一个写入的地址、数据和写入的个数,然后按照给定的地址开始写数据,注意红色字体。
写数据是怎么做的呢
首先是整理一下写入的页地址和需要写入多少页,每一页写入的话起始地址是什么
然后开始一页一页的写,当遇到跨页写入的时候,把第二页的地址写进去,写的个数继续写入就行
如果还有不明白的可以在下面留言,我给大家解答
还有一个地方很重要,就是我修改了库函数

  1. /**
  2.   * [url=home.php?mod=space&uid=247401]@brief[/url]  Programs a half word at a specified address.
  3.   * [url=home.php?mod=space&uid=536309]@NOTE[/url]   This function can be used for all STM32F10x devices.
  4.   * @param  Address: specifies the address to be programmed.
  5.   * @param  Data: specifies the data to be programmed.
  6.   * @retval FLASH Status: The returned value can be: FLASH_ERROR_PG,
  7.   *         FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
  8.   */
  9. FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data)
  10. {
  11.         FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
  12.   FLASH_Status status = FLASH_COMPLETE;
  13.   /* Check the parameters */
  14.   assert_param(IS_FLASH_ADDRESS(Address));

  15. #ifdef STM32F10X_XL
  16.   /* Wait for last operation to be completed */
  17.   status = FLASH_WaitForLastOperation(ProgramTimeout);

  18.   if(Address < FLASH_BANK1_END_ADDRESS)
  19.   {
  20.     if(status == FLASH_COMPLETE)
  21.     {
  22.       /* if the previous operation is completed, proceed to program the new data */
  23.       FLASH->CR |= CR_PG_Set;

  24.       *(__IO uint16_t*)Address = Data;
  25.       /* Wait for last operation to be completed */
  26.       status = FLASH_WaitForLastBank1Operation(ProgramTimeout);

  27.       /* Disable the PG Bit */
  28.       FLASH->CR &= CR_PG_Reset;
  29.     }
  30.   }
  31.   else
  32.   {
  33.     if(status == FLASH_COMPLETE)
  34.     {
  35.       /* if the previous operation is completed, proceed to program the new data */
  36.       FLASH->CR2 |= CR_PG_Set;

  37.       *(__IO uint16_t*)Address = Data;
  38.       /* Wait for last operation to be completed */
  39.       status = FLASH_WaitForLastBank2Operation(ProgramTimeout);

  40.       /* Disable the PG Bit */
  41.       FLASH->CR2 &= CR_PG_Reset;
  42.     }
  43.   }
  44. #else
  45.   /* Wait for last operation to be completed */
  46.   status = FLASH_WaitForLastOperation(ProgramTimeout);

  47.   if(status == FLASH_COMPLETE)
  48.   {
  49.     /* if the previous operation is completed, proceed to program the new data */
  50.     FLASH->CR |= CR_PG_Set;

  51.     *(__IO uint16_t*)Address = Data;
  52.     /* Wait for last operation to be completed */
  53.     status = FLASH_WaitForLastOperation(ProgramTimeout);

  54.     /* Disable the PG Bit */
  55.     FLASH->CR &= CR_PG_Reset;
  56.   }
  57. #endif  /* STM32F10X_XL */

  58.   /* Return the Program Status */
  59.   return status;
  60. }

大家能看出来吗?就是红色字体部分,增加了一个每次写入前清除所有异常状态。
为什么添加这个呢?
因为,如果你写入的数据的地址没有擦除,你就写入的话会导致异常状态的发生,而这个异常状态时要手动清除的,如果你没有清除这个异常状态,而继续写入数据的话,那么你后面写入任何数据都会报错,均写不进去,所以我在这里增加了一个异常状态清除,如果前面写入的数据报错了,不会影响我接下来的数据写入。
这里大家就清除为什么了吧。
写数据会了,那么再说一下读数据,其实这里读数据要比外部flash读取容易的多,我们直接读取地址,返回的就是地址存放的数据,是不是很简单
看下面的函数

  1. //读取指定地址的半字(16位数据)
  2. //faddr:读地址(此地址必须为2的倍数!!)
  3. //返回值:对应数据.
  4. u16 STMFLASH_ReadHalfWord(u32 faddr)
  5. {
  6.         return *(vu16*)faddr;
  7. }

  8. //从指定地址开始读出指定长度的数据
  9. //ReadAddr:起始地址
  10. //pBuffer:数据指针
  11. //NumToWrite:半字(16位)数

  12. void STMFLASH_Read(u32 ReadAddr,u16 *pBuffer,u16 NumToRead)           
  13. {
  14.         u16 i;
  15.         for(i=0;i<NumToRead;i++)
  16.         {
  17.                 pBuffer=STMFLASH_ReadHalfWord(ReadAddr);//读取2个字节.
  18.                 ReadAddr+=2;//偏移2个字节.        
  19.         }
  20. }


有没有很开心,读写数据就是这么简单就完成了。
以后如果我们想开发BootLoader、把剩余的flash利用起来,就都很简单了。我会把用到的数据手册当成附件挂到下面,大家可以自行下载
以后我们再一起学习其他的功能,最后打个广告,ST的芯片很给力,大家应该多支持,如果你觉得学到了知识的话,那么请留意评论谢谢










586146144105917dea.png

STM32F10xxx闪存编程参考手册_中文.pdf

464.42 KB, 下载次数: 37

打赏榜单

21小跑堂 打赏了 20.00 元 2021-09-18
理由:恭喜通过原创文章审核!请多多加油哦!

 楼主| binoo7 发表于 2021-9-17 13:28 | 显示全部楼层
一次传不完

cd00210843.pdf

1.97 MB, 下载次数: 12

STM8和STM32产品选型手册.pdf

2.4 MB, 下载次数: 13

STM32F10xxx闪存编程参考手册_英文.pdf

295.88 KB, 下载次数: 10

呐咯密密 发表于 2021-9-17 17:25 | 显示全部楼层
flash是必须整页整页的写吗?还有写flash的速度如何,这个有测试过吗。我可能需要用这个
呐咯密密 发表于 2021-9-17 17:26 | 显示全部楼层
还有,大佬贴代码用一下代码框,这样复制看的脑袋疼
 楼主| binoo7 发表于 2021-9-18 08:22 | 显示全部楼层
呐咯密密 发表于 2021-9-17 17:25
flash是必须整页整页的写吗?还有写flash的速度如何,这个有测试过吗。我可能需要用这个 ...

这个是可以单独写的,写入函数可以是任意长度
 楼主| binoo7 发表于 2021-9-18 08:22 | 显示全部楼层
呐咯密密 发表于 2021-9-17 17:26
还有,大佬贴代码用一下代码框,这样复制看的脑袋疼
  1. #include "stmflash.h"




  2. //读取指定地址的半字(16位数据)
  3. //faddr:读地址(此地址必须为2的倍数!!)
  4. //返回值:对应数据.
  5. u16 STMFLASH_ReadHalfWord(u32 faddr)
  6. {
  7.         return *(vu16*)faddr;
  8. }
  9. #if STM32_FLASH_WREN        //如果使能了写   
  10. //不检查的写入
  11. //WriteAddr:起始地址
  12. //pBuffer:数据指针
  13. //NumToWrite:半字(16位)数   
  14. void STMFLASH_Write_NoCheck(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)   
  15. {                                           
  16.         u16 i;
  17.         for(i=0;i<NumToWrite;i++)
  18.         {
  19.                 FLASH_ProgramHalfWord(WriteAddr,pBuffer[i]);
  20.           WriteAddr+=2;//地址增加2.
  21.         }  
  22. }
  23. //从指定地址开始写入指定长度的数据
  24. //WriteAddr:起始地址(此地址必须为2的倍数!!)
  25. //pBuffer:数据指针
  26. //NumToWrite:半字(16位)数(就是要写入的16位数据的个数.)
  27. #if STM32_FLASH_SIZE<256
  28. #define STM_SECTOR_SIZE 1024 //字节
  29. #else
  30. #define STM_SECTOR_SIZE        2048
  31. #endif                 
  32. u16 STMFLASH_BUF[STM_SECTOR_SIZE/2];//最多是2K字节
  33. void STMFLASH_Write(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)       
  34. {
  35.         u32 secpos;           //扇区地址
  36.         u16 secoff;           //扇区内偏移地址(16位字计算)
  37.         u16 secremain; //扇区内剩余地址(16位字计算)          
  38.         u16 i;   
  39.         u32 offaddr;   //去掉0X08000000后的地址
  40.         if(WriteAddr<STM32_FLASH_BASE||(WriteAddr>=(STM32_FLASH_BASE+1024*STM32_FLASH_SIZE)))return;//非法地址
  41.         FLASH_Unlock();                                                //解锁
  42.         offaddr=WriteAddr-STM32_FLASH_BASE;                //实际偏移地址.
  43.         secpos=offaddr/STM_SECTOR_SIZE;                        //扇区地址  0~127 for STM32F103RBT6
  44.         secoff=(offaddr%STM_SECTOR_SIZE)/2;                //在扇区内的偏移(2个字节为基本单位.)
  45.         secremain=STM_SECTOR_SIZE/2-secoff;                //扇区剩余空间大小   
  46.         if(NumToWrite<=secremain)
  47.         {
  48.           secremain=NumToWrite;//不大于该扇区范围
  49.         }
  50.         while(1)
  51.         {       
  52.                 STMFLASH_Read(((secpos*STM_SECTOR_SIZE)+STM32_FLASH_BASE),STMFLASH_BUF,STM_SECTOR_SIZE/2);//读出整个扇区的内容
  53.                 for(i=0;i<secremain;i++)//校验数据
  54. //                for(i=0;i<(STM_SECTOR_SIZE/2);i++)//校验数据
  55.                 {
  56.                         if(STMFLASH_BUF[secoff+i]!=0XFFFF)break;//需要擦除  
  57. //        if(STMFLASH_BUF[i]!=0XFFFF)break;//需要擦除                        
  58.                 }
  59.                 FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
  60.                 if(i<secremain)//需要擦除
  61. //                if(i<(STM_SECTOR_SIZE/2))//需要擦除
  62.                 {
  63.                         FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);

  64.                         FLASH_ErasePage(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE);//擦除这个扇区
  65.                         for(i=0;i<secremain;i++)//复制
  66.                         {
  67.                                 STMFLASH_BUF[i+secoff]=pBuffer[i];          
  68.                         }
  69.                         STMFLASH_Write_NoCheck(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE,STMFLASH_BUF,STM_SECTOR_SIZE/2);//写入整个扇区  
  70.                 }else STMFLASH_Write_NoCheck(WriteAddr,pBuffer,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                   
  71.                 if(NumToWrite==secremain)break;//写入结束了
  72.                 else//写入未结束
  73.                 {
  74.                                 secpos++;                                //扇区地址增1
  75.                                 secoff=0;                                //偏移位置为0          
  76.                            pBuffer+=secremain;          //指针偏移
  77.                                 WriteAddr+=(secremain*2);        //写地址偏移          
  78.                            NumToWrite-=secremain;        //字节(16位)数递减
  79.                                 if(NumToWrite>(STM_SECTOR_SIZE/2))
  80.                                 {
  81.                                   secremain=STM_SECTOR_SIZE/2;//下一个扇区还是写不完
  82.                                 }
  83.                                 else
  84.                                 {
  85.                                   secremain=NumToWrite;//下一个扇区可以写完了
  86.                                 }
  87.                 }         
  88.         }       
  89.         FLASH_Lock();//上锁
  90. }
  91. #endif

  92. //从指定地址开始读出指定长度的数据
  93. //ReadAddr:起始地址
  94. //pBuffer:数据指针
  95. //NumToWrite:半字(16位)数

  96. void STMFLASH_Read(u32 ReadAddr,u16 *pBuffer,u16 NumToRead)          
  97. {
  98.         u16 i;
  99.         for(i=0;i<NumToRead;i++)
  100.         {
  101.                 pBuffer[i]=STMFLASH_ReadHalfWord(ReadAddr);//读取2个字节.
  102.                 ReadAddr+=2;//偏移2个字节.       
  103.         }
  104. }

  105. //////////////////////////////////////////////////////////////////////////////////////////////////////
  106. //WriteAddr:起始地址
  107. //WriteData:要写入的数据
  108. void Test_Write(u32 WriteAddr,u16 WriteData)          
  109. {
  110.         STMFLASH_Write(WriteAddr,&WriteData,1);//写入一个字
  111. }
















wenleileilei 发表于 2021-9-21 06:55 | 显示全部楼层
没看懂
怀揣少年梦 发表于 2021-9-22 15:39 | 显示全部楼层
过程很详细,支持大佬
duo点 发表于 2021-9-22 15:42 来自手机 | 显示全部楼层
支持大佬,大佬优秀
kyzhd 发表于 2021-9-27 15:25 | 显示全部楼层
好帖,写的详细。
张岩0924 发表于 2023-2-3 11:33 | 显示全部楼层
为什么我没看见库函数修改的地方,这不是还是和原来一样吗?
您需要登录后才可以回帖 登录 | 注册

本版积分规则

49

主题

457

帖子

10

粉丝
快速回复 在线客服 返回列表 返回顶部