21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › 基于STM32（串口+DMA+空闲中断+环形缓冲区）实现 YMODEM ...
返回列表 发新帖我要提问

[STM32F4] 基于STM32（串口+DMA+空闲中断+环形缓冲区）实现 YMODEM协议IAP在线烧写程序

[复制链接]
 楼主| zero949079783 发表于 2024-4-21 16:01 | 显示全部楼层 |阅读模式
iap, DMA, DM, Ymodem, MODEM
本帖最后由 zero949079783 于 2024-7-14 10:27 编辑

基于STM32（串口+DMA+空闲中断+环形缓冲区）实现 YMODEM协议IAP在线烧写程序
BootLoader 扇区: 0x08000000  - 0x08004000 共16K大小

生成BIN: fromelf.exe --bin -o "$L@L.bin" "#L

上位机软件：SecureCRT

371096624ce7eeb687.png

Ymodem_STM32F1:
链接：https://pan.baidu.com/s/1SO34uS3flsdE8MdL4HHU0g?pwd=802v
提取码：802v
Ymodem_STM32F4:
链接：https://pan.baidu.com/s/13Kh6QzgNosYnYE5fJ-TB4Q?pwd=u5tj
提取码：u5tj
https://gitee.com/csx949089783/ymodem_-stm32-f4.git









YMODED接口函数：
复制
  1. #include "ymodem.h"
    

  2. #include "crc.h"
    

  3. #include "usart.h"
    

  4. #include "inner_flash.h"
    

  5. #include "delay.h"
    

  6. #include "key.h"
    

  7. #define YMODEM_TIME 10 
    


  8. 


  9. 

  10. typedef  void (*pFunction)(void);
    

  11. pFunction Jump_To_Application;
    


  12. 


  13. 

  14. typedef struct{
    

  15.         uint8_t OTA_FLAG :          1;
    

  16.         uint8_t YMODE_FLAG : 1;
    

  17.         uint8_t YMODE_Frist_FLAG :1;
    

  18.         uint8_t YMODE_Frist_Pack_FLAG: 1;
    

  19.         uint8_t YMODE_EOH_STX_DATALEN_FLAG :1;                
    

  20.         uint8_t fileName[256];                                                                                //文件名        
    

  21.         uint8_t  UpdataBuffer[STM32_PAGE_SIZE];                //接收数据缓冲区        
    

  22.         uint16_t time;                                                                                                                                        //OTA退出时间
    

  23.         uint16_t count;                                                        
    

  24.         uint32_t num;                                                                                                                        //接收数据包数
    

  25.         uint32_t STXnum;                                                                                                        //接收数据包数                
    

  26.         uint32_t crc;                                                                                                                        //CRC校验
    

  27.         uint32_t remanider;                                                                                                //数据余数
    

  28.         uint32_t packnum;                                                                                                        //数据总包数
    

  29.         uint32_t remaniderpacknum;                                                                //数据余数总包数(1024时)
    

  30.         uint32_t fileSize;                                                                                                //文件大小
    

  31.         uint32_t JumpAddress;                                                                                        //APP跳转地址
    

  32. }YMODEM_T ;
    


  33. 

  34. YMODEM_T ymodem_t;
    


  35. 

  36. void Ymodem_Init(void)
    

  37. {
    

  38.         memset(&ymodem_t,0,sizeof(ymodem_t));
    

  39.         ymodem_t.time = YMODEM_TIME;
    

  40. }
    


  41. 


  42. 

  43. static void BootLoader_To_App(void)
    

  44. {
    

  45.         Delay_ms(1);
    

  46.         printf("\r\n");
    

  47.         printf("BootLoader_To_App.....\r\n");
    

  48.         Delay_ms(1);
    

  49.         FLASH_Lock();
    

  50.         
    

  51.         SysTick->CTRL &= SysTick_CTRL_TICKINT_Msk;        //关滴答定时器
    

  52.         
    

  53.   ymodem_t.JumpAddress = *(__IO uint32_t*) (APPLICATION_ADDRESS + 4);        
    

  54.   /* Jump to user application */
    

  55.   Jump_To_Application = (pFunction) ymodem_t.JumpAddress;
    

  56.   /* Initialize user application's Stack Pointer */
    

  57.   __set_MSP(*(__IO uint32_t*) APPLICATION_ADDRESS);
    

  58.   Jump_To_Application();
    

  59. }
    


  60. 

  61. static void BootLoader_SendByte(uint8_t data)
    

  62. {
    

  63.         Usartx_SendArray(USART1,&data,1);
    

  64. }
    


  65. 

  66. /*************************************************************************
    

  67. *        函 数 名: BootLoader_EraseFlash
    

  68. *        功能说明: Flash扇区擦除
    

  69. *        形    参：startSectorAddr：起始扇区地址    numSector：扇区个数
    

  70. *        返 回 值: 无
    

  71. **************************************************************************/
    

  72. void BootLoader_EraseFlash(void)
    

  73. {
    

  74.         STM32_EraseFlash(STM32_A_SADDR,11);
    

  75. }
    


  76. 

  77. /*************************************************************************
    

  78. *        函 数 名: BootLoader_WriteFlash
    

  79. *        功能说明: 数据写入
    

  80. *        形    参：startAddr：起始地址   writeData：写入数据   numByte：写入字节数
    

  81. *        返 回 值: 无
    

  82. **************************************************************************/
    

  83. static void BootLoader_WriteFlash(uint32_t startAddr, uint32_t* writeData, uint32_t numByte)
    

  84. {
    

  85.         STM32_WriteFlash(startAddr,writeData,numByte);
    

  86. }
    


  87. 


  88. 


  89. 

  90. void BootLoader_Meun(void)
    

  91. {
    

  92.         static uint16_t times = 0;
    

  93.         times ++;
    


  94. 

  95.          if(ymodem_t.OTA_FLAG == YMODEM_DISABLE && times%1000 == 0)
    

  96.                 {                
    

  97.                         ymodem_t.time --;
    

  98.                         
    

  99.                         printf(" \r\n %ds后退出BootLoader\r\n ",ymodem_t.time);
    

  100.                         if(ymodem_t.time <= 0)
    

  101.                         {
    

  102.                                 BootLoader_To_App();
    

  103.                         }
    

  104.                 }
    

  105.                 else if(ymodem_t.YMODE_FLAG == YMODEMD_ENABLE && times %500 == 0)
    

  106.                 {
    

  107.                         ymodem_t.time = YMODEM_TIME;
    

  108.                         BootLoader_SendByte(CA);        //发送握手
    

  109.                 }
    


  110. 

  111.         //按键双击进入OTA
    

  112.         if( get_Key_Val() == 0x51 && ymodem_t.YMODE_FLAG == YMODEM_DISABLE && ymodem_t.OTA_FLAG == YMODEM_DISABLE)
    

  113.         {        
    

  114.                         printf("EraseFlash......\r\n");
    

  115.                         BootLoader_EraseFlash();
    

  116.                         printf("EraseFlash successfully \r\n");
    

  117.                         ymodem_t.OTA_FLAG = 1;
    

  118.                         ymodem_t.YMODE_FLAG = 1;
    

  119.         }
    


  120. 


  121. 

  122. }
    


  123. 

  124. static void BootLoader_Com(uint8_t *data)
    

  125. {
    

  126.         if(memcmp(data,"1",1)==0 )        //当接收到上位机或者双击时，进入OTA
    

  127.         {
    

  128.                         printf("EraseFlash......\r\n");
    

  129.                         BootLoader_EraseFlash();
    

  130.                         printf("EraseFlash successfully \r\n");
    

  131.                         ymodem_t.OTA_FLAG = 1;
    

  132.                         ymodem_t.YMODE_FLAG = 1;
    

  133.         }
    

  134. }
    


  135. 

  136. /***************************************************************************
    

  137. Ymodem数据帧:        
    

  138.                 帧头                  包号 包号反码         信息块                                                 校验
    

  139.         SOH/STX                 PN                 XPN                         DATA 128/1024                 CRC16(CRCH CRCL) 
    

  140.                 1:对于SOH帧，若余下数据小于128字节，则以0x1A填充，该帧长度仍为133字节。
    

  141.                 2:对于STX帧需考虑几种情况
    


  142. 

  143. 帧长度: 
    

  144.                 1:以SOH(0x01)开始的数据包，信息块是128字节，该类型帧总长度为133字节
    

  145.                 2:以STX(0x02)开始的数据包，信息块是1024字节，该类型帧总长度为1029字节
    

  146.                         a:●余下数据等于1024字节，以1029长度帧发送；
    

  147.                         b:●余下数据小于1024字节，但大于128字节，以1029字节帧长度发送，无效数据以0x1A填充
    

  148.                         c:●余下数据等于128字节，以133字节帧长度发送
    

  149.                         d:●余下数据小于128字节，以133字节帧长度发送，无效数据以0x1A填充
    


  150. 

  151. 包序号:
    

  152.         数据包序号只有1字节，因此计算范围是0~255；对于数据包大于255的，序号归零重复计算。
    


  153. 

  154. 校验:
    

  155.         Ymodem采用的是CRC16校验算法，校验值为2字节，传输时CRC高八位在前，低八位在后；CRC计算数据为信息块数据，不包含帧头、包号、包号反码
    


  156. 

  157. 起始帧:
    

  158.         Ymodem起始帧并不直接传输文件内容，而是先将文件名和文件大小置于数据帧中传输；起始帧是以SOH 133字节长度帧传输，格式如下
    

  159.         帧头                          包号 包号反码                 文名件称                                          文件大小                                                        填充区                                 校验
    

  160.         SOH/STX                PN                 XPN                                fileName+0x00                                fileSize+0x00                                                0x00                                CRC16(CRCH CRCL)
    


  161. 

  162. Ymodem结束帧
    

  163.                 帧头                  包号         包号反码                         信息块                                                 校验
    

  164.                 SOH                                 PN                         XPN                                  0x00                                                        CRC16(CRCH CRCL) 
    

  165.                 
    

  166.                 
    

  167. 文件传输过程
    


  168. 

  169. 文件的传输过程，以具体的例子说明。把foo.c，大小为4196Byte（16进制为0x1064）的文件作为传输的对象，则它的传输过程如下：
    

  170. 发送端----------------------------------------------------------------接收端
    


  171. 

  172. <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< C
    


  173. 

  174. SOH 00 FF “foo.c” "1064’’ NUL[118] CRC CRC >>>>>>>>>>>>>
    


  175. 

  176. <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ACK
    


  177. 

  178. <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< C
    


  179. 

  180. STX 01 FE data[1024] CRC CRC>>>>>>>>>>>>>>>>>>>>>>>>
    


  181. 

  182. <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ACK
    


  183. 

  184. STX 02 FD data[1024] CRC CRC>>>>>>>>>>>>>>>>>>>>>>>
    


  185. 

  186. <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ACK
    


  187. 

  188. STX 03 FC data[1024] CRC CRC>>>>>>>>>>>>>>>>>>>>>>>
    


  189. 

  190. <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ACK
    


  191. 

  192. STX 04 FB data[1024] CRC CRC>>>>>>>>>>>>>>>>>>>>>>>
    


  193. 

  194. <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ACK
    


  195. 

  196. SOH 05 FA data[100] 1A[28] CRC CRC>>>>>>>>>>>>>>>>>>
    


  197. 

  198. <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ACK
    


  199. 

  200. EOT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    


  201. 

  202. <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< NAK
    


  203. 

  204. EOT>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    


  205. 

  206. <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ACK
    


  207. 

  208. <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< C
    


  209. 

  210. SOH 00 FF NUL[128] CRC CRC >>>>>>>>>>>>>>>>>>>>>>>
    


  211. 

  212. <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ACK        
    

  213. *******************************************************************************************/
    


  214. 

  215. void Ymodem_Receive(uint8_t *data,uint16_t datalen)
    

  216. {
    

  217.         char *fileSizebuff;
    

  218.         char fileSize[50];                        //文件大小
    

  219.         uint8_t i = 0,j=0;
    

  220.         
    

  221.         if(ymodem_t.OTA_FLAG == YMODEM_DISABLE)
    

  222.         {
    

  223.                 BootLoader_Com(data);
    

  224.         }
    

  225.         
    

  226.         //当是第0包数据时，和最1后才能进入， 
    

  227.         if((data[0] == SOH && data[1] == 0x00 && data[2] == 0xff && ymodem_t.YMODE_Frist_Pack_FLAG == YMODEM_DISABLE && datalen == YMODE_SOH_PACKLEN) || ymodem_t.YMODE_Frist_FLAG == YMODEMD_ENABLE )        //Ymodem起始帧: 113
    

  228.         {                
    

  229.                         ymodem_t.crc = CRC16_XMODEM(&data[3],YMODE_SOH_DATALEN);
    

  230.                         if(ymodem_t.crc == ((data[YMODE_SOH_PACKLEN - 2]<<8) |data[YMODE_SOH_PACKLEN - 1]))        //CRC
    

  231.                         {
    

  232.                                         
    

  233.                                         if(ymodem_t.YMODE_Frist_FLAG == YMODEM_DISABLE)        //第1次
    

  234.                                         {
    

  235.                                                 ymodem_t.YMODE_FLAG = YMODEM_DISABLE;
    

  236.                                                 ymodem_t.YMODE_Frist_Pack_FLAG = YMODEMD_ENABLE ;        //第1包接收标志位置使能，说时第一包接好
    

  237.                                                 for(i=0;data[3+i] !='\0';i++)                //读取文件名
    

  238.                                                 {
    

  239.                                                         ymodem_t.fileName[i] = data[3+i];
    

  240.                                                 }
    

  241.                                                 i++;
    

  242.                                                 for(j=0;data[3+i+j] != '\0';j++)        //读取文件大小
    

  243.                                                 {
    

  244.                                                         fileSize[j] = data[3+i+j];
    

  245.                                                 }
    

  246.                                                 
    

  247.                                                         ymodem_t.fileSize = strtol(fileSize,&fileSizebuff,10);
    

  248.                                                         ymodem_t.remanider =         ymodem_t.fileSize % YMODE_SOH_DATALEN;        
    

  249.                                                         ymodem_t.packnum   =        ymodem_t.fileSize /        YMODE_SOH_DATALEN;
    

  250.                                                         if(ymodem_t.remanider > 0)
    

  251.                                                                 ymodem_t.packnum = ymodem_t.packnum+1;
    

  252.                                                         
    

  253.                                                 BootLoader_SendByte(ACK);        //正确发送ACK
    

  254.                                                 BootLoader_SendByte(CA);
    

  255.                                         }
    

  256.                                         else if(ymodem_t.YMODE_Frist_FLAG == YMODEMD_ENABLE)
    

  257.                                         {
    

  258.                                                 
    

  259.                                                 BootLoader_SendByte(ACK);        //正确发送ACK
    

  260.                                                 
    

  261.                                                 BootLoader_SendByte(CA);        //正确发送ACK
    


  262. 

  263.                                                 Delay_ms(20);
    

  264.                                                 printf("\r\n");
    

  265.                                                 printf("fileName ：%s \r\n",ymodem_t.fileName);
    

  266.                                                 printf("fileSize ：%d Byte\r\n",ymodem_t.fileSize);
    

  267.                                                 printf("File uploaded successfully  \r\n");
    

  268.                                                 printf("\r\n");
    

  269.                                                 Ymodem_Init();
    

  270.                                                 BootLoader_To_App();
    

  271.                                                 
    

  272.                                         }
    

  273.                         }
    

  274.                         else{
    

  275.                                 BootLoader_SendByte(NAK);        //错误发送NAK
    

  276.                         }
    

  277.                         
    

  278.         }
    

  279.         else if((data[0] == STX && data[1] == 0x00 && data[2] == 0xff && ymodem_t.YMODE_Frist_Pack_FLAG == YMODEM_DISABLE && datalen == YMODE_STX_PACKLEN))        ////Ymodem起始帧: 1024
    

  280.         {
    

  281.                         ymodem_t.crc = CRC16_XMODEM(&data[3],YMODE_STX_DATALEN);
    

  282.                         if(ymodem_t.crc == ((data[YMODE_STX_PACKLEN - 2]<<8) |data[YMODE_STX_PACKLEN - 1]))        //CRC
    

  283.                         {
    

  284.                                         if(ymodem_t.YMODE_Frist_FLAG == YMODEM_DISABLE)        //第1次
    

  285.                                         {
    

  286.                                                 ymodem_t.YMODE_FLAG = YMODEM_DISABLE;
    

  287.                                                 ymodem_t.YMODE_Frist_Pack_FLAG = YMODEMD_ENABLE;        //第1包接收标志位置使能，说时第一包接好
    

  288.                                                 
    

  289.                                                 for(i=0;data[3+i] !='\0';i++)                //读取文件名
    

  290.                                                 {
    

  291.                                                         ymodem_t.fileName[i] = data[3+i];
    

  292.                                                 }
    

  293.                                                 i++;
    

  294.                                                 for(j=0;data[3+i+j] != '\0';j++)        //读取文件大小
    

  295.                                                 {
    

  296.                                                         fileSize[j] = data[3+i+j];
    

  297.                                                 }
    

  298.                                                         ymodem_t.fileSize = strtol(fileSize,&fileSizebuff,10);
    

  299.                                                 
    


  300. 

  301.                                                 
    

  302.                                                         //数据1024时，数据是1024时，按1024接收，当小于1024时，以每包128个字传接收，直到所有数据收完
    

  303.                                                         ymodem_t.remanider =         ymodem_t.fileSize % YMODE_STX_DATALEN;                //余下字节个数
    

  304.                                                         
    

  305.                                                         ymodem_t.remaniderpacknum = ymodem_t.remanider / YMODE_SOH_DATALEN;        //余下字节以128接收的包数据
    

  306.                                                         
    

  307.                                                         ymodem_t.packnum   =        (ymodem_t.fileSize /        YMODE_STX_DATALEN)  ;                //1024总包数        
    

  308.                                                         if(ymodem_t.remanider  > 0)
    

  309.                                                         {
    

  310.                                                                 ymodem_t.remaniderpacknum = ymodem_t.remaniderpacknum +1;
    

  311.                                                                 ymodem_t.packnum = ymodem_t.packnum+1;
    

  312.                                                         }
    

  313.                                                         
    

  314.                                                         ymodem_t.YMODE_EOH_STX_DATALEN_FLAG = YMODEMD_ENABLE;                        
    

  315.                                         
    

  316.                                                 BootLoader_SendByte(ACK);        //正确发送ACK
    

  317.                                                 BootLoader_SendByte(CA);
    

  318.                                                         
    

  319.                                         }        
    

  320.                         }
    

  321.                         else{
    

  322.                                 BootLoader_SendByte(NAK);        //错误发送NAK
    

  323.                         }
    

  324.         }
    

  325.         else if(data[0] == SOH && datalen == YMODE_SOH_PACKLEN)        //Ymodem数据帧：当数据以大小是128字节时
    

  326.         {                        
    

  327.                         ymodem_t.crc = CRC16_XMODEM(&data[3],YMODE_SOH_DATALEN);
    

  328.                         if(ymodem_t.crc == ((data[YMODE_SOH_PACKLEN - 2]<<8) |data[YMODE_SOH_PACKLEN - 1]))        //CRC
    

  329.                         {
    

  330.                                                 ymodem_t.num ++;        //已接收的数据包数量+1
    

  331.                                         
    

  332.                                                 //将本次接收的数据，暂存到ymodem_t.UpdataBuffer缓冲                                                
    

  333.                                                         memcpy(&ymodem_t.UpdataBuffer[((ymodem_t.num - 1) % (STM32_PAGE_SIZE / YMODE_SOH_DATALEN)) * YMODE_SOH_DATALEN],&data[3], YMODE_SOH_DATALEN);   //将本次接收的数据，暂存到UpDataA.Updatabuff缓冲区
    

  334.                                                 if(ymodem_t.YMODE_EOH_STX_DATALEN_FLAG == YMODEM_DISABLE)        //当是128每包数据时
    

  335.                                                 {
    

  336.                                                         if(((ymodem_t.num % (STM32_PAGE_SIZE/YMODE_SOH_DATALEN)) == 0) &&( ymodem_t.packnum!=ymodem_t.num ))        //每满一个扇区写入Flash
    

  337.                                                         {                                                        
    

  338.                                                                 //写入到单片机A区相应的扇区
    

  339.                                                                 BootLoader_WriteFlash(STM32_A_SADDR + (((ymodem_t.num / (STM32_PAGE_SIZE / YMODE_SOH_DATALEN)) -1) * STM32_PAGE_SIZE), (uint32_t *)ymodem_t.UpdataBuffer,STM32_PAGE_SIZE);    //写入到单片机A区相应的扇区
    

  340.                                                                 
    

  341.                                                                 //备份FLASG写入
    

  342.                                                         }
    

  343.                                                         else if(((ymodem_t.num % (STM32_PAGE_SIZE/YMODE_SOH_DATALEN)) != 0) &&(ymodem_t.packnum==ymodem_t.num))//最后一包数，判断是否还有不满1扇区1024字节的数据，如果有进入if，把剩余的小尾巴写入
    

  344.                                                         {
    

  345.                                                                 //写入到单片机A区相应的扇区
    

  346.                                                                 BootLoader_WriteFlash(STM32_A_SADDR  + (((ymodem_t.num / (STM32_PAGE_SIZE / YMODE_SOH_DATALEN))) * STM32_PAGE_SIZE), (uint32_t *)ymodem_t.UpdataBuffer,(ymodem_t.num % (STM32_PAGE_SIZE / YMODE_SOH_DATALEN)) * YMODE_SOH_DATALEN);    //写入到单片机A区相应的扇区
    

  347.                                                                 
    

  348.                                                                 //备份FLASG写入        
    

  349.                                                         }
    

  350.                                                 }
    

  351.                                                 else {
    

  352.                                                         if(((ymodem_t.num % (STM32_PAGE_SIZE/YMODE_SOH_DATALEN)) == 0) &&( ymodem_t.remaniderpacknum!=ymodem_t.num ))        //每满一个扇区写入Flash
    

  353.                                                         {                                                        
    

  354.                                                                 //写入到单片机A区相应的扇区
    

  355.                                                                 BootLoader_WriteFlash(STM32_A_SADDR + (ymodem_t.STXnum * STM32_PAGE_SIZE)+(((ymodem_t.num / (STM32_PAGE_SIZE / YMODE_SOH_DATALEN)) -1) * STM32_PAGE_SIZE), (uint32_t *)ymodem_t.UpdataBuffer,STM32_PAGE_SIZE);    //写入到单片机A区相应的扇区
    

  356.                                                                 
    

  357.                                                                 //备份FLASG写入
    

  358.                                                         }        
    

  359.                                                         else if(((ymodem_t.num % (STM32_PAGE_SIZE/YMODE_SOH_DATALEN)) != 0) &&(ymodem_t.remaniderpacknum==ymodem_t.num))//最后一包数，判断是否还有不满1扇区1024字节的数据，如果有进入if，把剩余的小尾巴写入
    

  360.                                                         {
    

  361.                                                                 //写入到单片机A区相应的扇区
    

  362.                                                                 BootLoader_WriteFlash(STM32_A_SADDR + (ymodem_t.STXnum * STM32_PAGE_SIZE) + (((ymodem_t.num / (STM32_PAGE_SIZE / YMODE_SOH_DATALEN))) * STM32_PAGE_SIZE), (uint32_t *)ymodem_t.UpdataBuffer,(ymodem_t.num % (STM32_PAGE_SIZE / YMODE_SOH_DATALEN)) * YMODE_SOH_DATALEN);    //写入到单片机A区相应的扇区                                                
    

  363.                                                                 
    

  364.                                                                 //备份FLASG写入        
    

  365.                                                         }                                                        
    

  366.                                                 }
    


  367. 

  368.                                                 BootLoader_SendByte(ACK);        //正确发送ACK
    

  369.                                                         
    

  370.                         }
    

  371.                         else{
    

  372.                                 BootLoader_SendByte(NAK);        //错误发送NAK
    

  373.                         }
    

  374.         }
    

  375.         else if(data[0] == STX && datalen == YMODE_STX_PACKLEN)        //Ymodem数据帧：当数据是1029字节时
    

  376.         {
    

  377.                         ymodem_t.crc = CRC16_XMODEM(&data[3],YMODE_STX_DATALEN);
    

  378.                         if(ymodem_t.crc == ((data[YMODE_STX_PACKLEN - 2]<<8) |data[YMODE_STX_PACKLEN - 1]))        //CRC
    

  379.                         {
    

  380.                                 ymodem_t.STXnum++;
    

  381.                                 memcpy(&ymodem_t.UpdataBuffer[((ymodem_t.STXnum- 1) % (STM32_PAGE_SIZE / YMODE_STX_DATALEN)) * YMODE_STX_DATALEN],&data[3], YMODE_STX_DATALEN);   //将本次接收的数据，暂存到UpDataA.Updatabuff缓冲区
    

  382.                                 if(((ymodem_t.STXnum % (STM32_PAGE_SIZE/YMODE_STX_DATALEN)) == 0) &&( ymodem_t.packnum!=ymodem_t.STXnum))        //每满一个扇区写入Flash
    

  383.                                 {                                                        
    

  384.                                         //写入到单片机A区相应的扇区
    

  385.                                         BootLoader_WriteFlash(STM32_A_SADDR + (((ymodem_t.STXnum/ (STM32_PAGE_SIZE / YMODE_STX_DATALEN)) -1) * STM32_PAGE_SIZE), (uint32_t *)ymodem_t.UpdataBuffer,STM32_PAGE_SIZE);    //写入到单片机A区相应的扇区
    

  386.                                         
    

  387.                                         //备份FLASG写入
    

  388.                                         
    

  389.                                 }
    

  390.                                 
    

  391.                                 BootLoader_SendByte(ACK);        //正确发送ACK
    

  392.                         }
    

  393.                         else{
    

  394.                                 BootLoader_SendByte(NAK);        //错误发送NAK
    

  395.                         }
    

  396.                 
    

  397.         }
    

  398.         else if(data[0] == EOT && datalen == YMODE_EOT_DATALEN)        //当接收到EOT
    

  399.         {        
    

  400.                 if(ymodem_t.count == 0)
    

  401.                 {
    

  402.                         ymodem_t.count ++;
    

  403.                         BootLoader_SendByte(NAK);        //正确发送NAK
    


  404. 

  405.                 }
    

  406.                 else if(ymodem_t.count == 1)
    

  407.                 {
    

  408.                         ymodem_t.YMODE_Frist_FLAG = YMODEMD_ENABLE;
    

  409.                         ymodem_t.count = 0;
    

  410.                         BootLoader_SendByte(ACK);        //正确发送ACK                        
    

  411.                         BootLoader_SendByte(CA);        //正确发送C        
    


  412. 

  413.                 }
    

  414.         }
    

  415.         else if(data[0] == CAN && data[1] == CAN && data[2] == CAN && data[3] == CAN && data[4] == CAN )        //取消传输命令，连续发送5个该命令
    

  416.         {
    

  417.                         ymodem_t.OTA_FLAG = YMODEM_DISABLE;
    

  418.                         Ymodem_Init();
    

  419.         }
    

  420. }
    


  421.

复制
  1. #ifndef __YMODEM_H
    

  2. #define __YMODEM_H
    


  3. 

  4. #include "stm32f4xx.h"
    


  5. 

  6. #define  STM32_FLASH_SADDR   0x08000000                                                              //FLASH扇区起始地址
    

  7. #define  STM32_PAGE_SIZE     1024                                                                    //FLASH扇区大小
    

  8. #define  STM32_PAGE_NUM      1024                                                                     //FLASH扇区总个数
    

  9. #define  STM32_B_PAGE_NUM    16                                                                      //BootLoader 扇区个数
    


  10. 

  11. #define  STM32_A_PAGE_NUM    (STM32_PAGE_NUM - STM32_B_PAGE_NUM)                                                                                                         //APP扇区个数
    

  12. #define  STM32_A_START_PAGE  (STM32_B_PAGE_NUM)                                                                                                                                                                                //APP扇区起始数
    

  13. #define  STM32_A_SADDR       (STM32_FLASH_SADDR + STM32_A_START_PAGE * STM32_PAGE_SIZE)                //APP扇区起始地址
    


  14. 

  15. #define APPLICATION_ADDRESS (STM32_A_SADDR)                                                                                                                                                                                                //APP跳转地址
    


  16. 


  17. 

  18. #define YMODE_SOH_PACKLEN 133                        //SOH数据包长度
    

  19. #define YMODE_STX_PACKLEN 1029                //SOH数据包长度        
    

  20. #define YMODE_SOH_DATALEN 128                        //SOH有效数据长度
    

  21. #define YMODE_STX_DATALEN 1024                //SOH有效数据长度        
    

  22. #define YMODE_EOT_DATALEN   1
    


  23. 

  24. typedef enum {YMODEM_DISABLE = 0, YMODEMD_ENABLE = !YMODEM_DISABLE} YmodemState;
    


  25. 

  26. typedef enum{
    

  27.         SOH = 0X01,//133字节长度帧
    

  28.         STX = 0X02,//1024字节长度帧
    

  29.         EOT = 0X04,//文件传输结束命令
    

  30.         ACK = 0X06,//接收正确应答命令
    

  31.         NAK = 0X15,//重传当前数据包请求命令
    

  32.         CAN = 0X18,//取消传输命令，连续发送5个该命令
    

  33.         CA   = 0X43,//字符C ,发送握手        
    

  34. }YMODEM_COM;
    


  35. 

  36. void Ymodem_Init(void);
    

  37. void BootLoader_Meun(void);
    

  38. void Ymodem_Receive(uint8_t *data,uint16_t datalen);
    

  39. #endif 
    


  40.
usart.c
复制
  1. #include "usart.h"
    

  2. #include "delay.h"
    

  3. uint8_t Usart1_RxBuffer[UARTx_RX_SIZE] = {0};      //串口1接收缓冲区
    

  4. uint8_t Usart1_TxBuffer[UARTx_TX_SIZE] = {0};      //串口1发送缓冲区
    

  5. Usartx_Control_Block  usart1;                                  //串口1控制结构体
    


  6. 

  7. void (*usartTakeFunCb)(uint8_t *data,uint16_t datalen);
    


  8. 

  9. void usart1TakeCb(void(*pFunc)(uint8_t *data,uint16_t datalen))
    

  10. {
    

  11.         usartTakeFunCb = pFunc;
    

  12. }
    


  13. 

  14. void usart1_take(void)
    

  15. {
    

  16.         if(usart1.RxOutPtr != usart1.RxInPtr)
    

  17.         {
    

  18.                 usartTakeFunCb(usart1.RxOutPtr->start,(usart1.RxOutPtr->end - usart1.RxOutPtr->start+1));
    

  19.                 
    

  20.                 usart1.RxOutPtr++;
    

  21.                 if(usart1.RxOutPtr == usart1.RxEndPtr)
    

  22.                 {
    

  23.                         usart1.RxOutPtr = &usart1.RxLocation[0];
    

  24.                 }
    

  25.         }
    


  26. 

  27.         if((usart1.TxOutPtr != usart1.TxInPtr) &&( usart1.TxState == 0))
    

  28.         {
    

  29.                 usart1.TxState = 1;
    

  30.                 
    

  31.                 DMA_Cmd(DMA2_Stream7,ENABLE);        
    

  32.                 while (DMA_GetCmdStatus(DMA2_Stream7) != DISABLE);        //确保DMA可以被设置
    

  33.                 DMA_SetCurrDataCounter(DMA2_Stream7, UARTx_TX_MAX);                
    

  34.                 usart1.TxOutPtr++;
    

  35.                 if(usart1.TxOutPtr == usart1.TxEndPtr)
    

  36.                 {
    

  37.                         usart1.TxOutPtr = &usart1.TxLocation[0];
    

  38.                 }
    

  39.         
    

  40.         }        
    

  41. }
    


  42. 

  43. void USART1_Init(uint32_t bandRate)
    

  44. {
    

  45.         Usart1_PtrInit();
    

  46.         USART1_GPIO_Init();
    

  47.         Delay_ms(1);
    

  48.         USART1_Config_Init(bandRate);
    

  49.         Delay_ms(1);
    

  50.         USART1_DMA_Init();         
    

  51. }
    


  52. 

  53. /*************************************************************************
    

  54. *        函 数 名: Uart1_RX_PtrInit
    

  55. *        功能说明: 串口1控制结构体各个指针初始化
    

  56. *        形    参：无
    

  57. *        返 回 值: 无
    

  58. **************************************************************************/
    

  59. void Usart1_PtrInit(void)
    

  60. {        
    

  61.         usart1.RxInPtr  = &usart1.RxLocation[0];
    

  62.         usart1.RxOutPtr = &usart1.RxLocation[0];
    

  63.         usart1.RxEndPtr = &usart1.RxLocation[9];
    

  64.         usart1.RxCounter = 0;
    

  65.         usart1.RxInPtr->start = Usart1_RxBuffer;
    


  66. 

  67.         usart1.TxInPtr   = &usart1.TxLocation[0];
    

  68.         usart1.TxOutPtr  = &usart1.TxLocation[0];
    

  69.         usart1.TxEndPtr  = &usart1.TxLocation[9];
    

  70.         usart1.TxCounter = 0;
    

  71.         usart1.TxInPtr->start = Usart1_TxBuffer;
    

  72.         
    

  73.         memset(Usart1_RxBuffer,0,UARTx_RX_SIZE);
    

  74.         memset(Usart1_TxBuffer,0,UARTx_RX_SIZE);
    

  75. }
    


  76. 

  77. /*************************************************************************
    

  78. *        函 数 名: Usart1_GPIO_Config
    

  79. *        功能说明: 串口1 GPIO初始化
    

  80. *        形    参：无
    

  81. *        返 回 值: 无
    

  82. **************************************************************************/
    


  83. 

  84. void USART1_GPIO_Init(void)
    

  85. {
    

  86.   GPIO_InitTypeDef GPIO_InitStructure;
    

  87.                 
    

  88.   RCC_AHB1PeriphClockCmd( RCC_AHB1Periph_GPIOB, ENABLE);
    

  89.         
    

  90.   /* 配置Tx引脚为复用功能  */
    

  91.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
    

  92.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    

  93.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    

  94.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;        
    

  95.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;         
    

  96.   GPIO_Init(GPIOB, &GPIO_InitStructure);
    

  97.         
    

  98.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7  ;
    

  99.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;        
    

  100.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; 
    

  101.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;        
    

  102.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;           
    

  103.   GPIO_Init(GPIOB, &GPIO_InitStructure);        
    

  104.         
    

  105.         
    

  106.         /*串口上电发送0x00的解决*/
    

  107.   /* 连接 PXx 到 USARTx_Tx*/
    

  108.         GPIO_PinAFConfig(GPIOB,GPIO_PinSource6, GPIO_AF_USART1);
    


  109. 

  110.         /*  连接 PXx 到 USARTx__Rx*/
    

  111.         GPIO_PinAFConfig(GPIOB,GPIO_PinSource7,GPIO_AF_USART1);                
    

  112. }
    


  113. 

  114. /*************************************************************************
    

  115. *        函 数 名: Usart1_Config
    

  116. *        功能说明: 串口1初始化
    

  117. *        形    参：bandRate：波特率
    

  118. *        返 回 值: 无
    

  119. **************************************************************************/
    

  120. void USART1_Config_Init(uint32_t bandRate)
    

  121. {
    


  122. 

  123.   /* 使能 UART 时钟 */
    

  124.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); 
    

  125.         usart1.usart.USART_BaudRate                       = bandRate;
    

  126.         usart1.usart.USART_WordLength                   = USART_WordLength_8b;                     //8bit数据位
    

  127.         usart1.usart.USART_StopBits                           = USART_StopBits_1;                        //1bit停止位
    

  128.         usart1.usart.USART_Parity                           =          USART_Parity_No;                         //无校验
    

  129.         usart1.usart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    

  130.         usart1.usart.USART_Mode                               = USART_Mode_Rx | USART_Mode_Tx;       
    

  131.         USART_Init(USART1, &usart1.usart);        
    


  132. 

  133. //        USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);        //开启空闲中断
    

  134.         USART_ITConfig(USART1,USART_IT_IDLE,ENABLE);        //开启空闲中断
    

  135. //        USART_ITConfig(USART1,USART_IT_TC,ENABLE);        //开启发送完成中断        
    

  136.         USART_Cmd(USART1, ENABLE);                                                                                                                                //使能串口        
    

  137.         
    

  138.         USART_DMACmd(USART1,USART_DMAReq_Rx, ENABLE);                                                                        //使能RX DMA
    

  139.         USART_DMACmd(USART1,USART_DMAReq_Tx, ENABLE);                                                                        //使能RX DMA                
    

  140. }
    


  141. 

  142. /*************************************************************************
    

  143. *        函 数 名: Uart1_DMA_Init
    

  144. *        功能说明: 串口1 DMA初始化
    

  145. *        形    参：无
    

  146. *        返 回 值: 无
    

  147. **************************************************************************/
    

  148. void USART1_DMA_Init(void)
    

  149. {
    

  150.         
    

  151.         NVIC_InitTypeDef NVIC_InitStructure;
    

  152.         
    

  153.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2,ENABLE);
    

  154.   /* 复位初始化DMA数据流 */
    

  155.   DMA_DeInit(DMA2_Stream5);
    


  156. 

  157.   /* 确保DMA数据流复位完成 */
    

  158.   while (DMA_GetCmdStatus(DMA2_Stream5) != DISABLE)  {
    

  159.   }
    


  160. 

  161.   /*usart1 rx对应dma2，通道4，数据流2*/        
    

  162.   usart1.dmarx.DMA_Channel = DMA_Channel_4;  
    

  163.   /*设置DMA源：串口数据寄存器地址*/
    

  164.   usart1.dmarx.DMA_PeripheralBaseAddr =  (USART1_BASE + 0x04);         
    

  165.   /*内存地址(要传输的变量的指针)*/
    

  166.   usart1.dmarx.DMA_Memory0BaseAddr = (uint32_t)Usart1_RxBuffer;
    

  167.   /*方向：从内存到外设*/                
    

  168.   usart1.dmarx.DMA_DIR = DMA_DIR_PeripheralToMemory;        
    

  169.   /*传输大小DMA_BufferSize=RECEIVEBUFF_SIZE*/        
    

  170.   usart1.dmarx.DMA_BufferSize = UARTx_RX_MAX+1;
    

  171.   /*外设地址不增*/            
    

  172.   usart1.dmarx.DMA_PeripheralInc = DMA_PeripheralInc_Disable; 
    

  173.   /*内存地址自增*/
    

  174.   usart1.dmarx.DMA_MemoryInc = DMA_MemoryInc_Enable;        
    

  175.   /*外设数据单位*/        
    

  176.   usart1.dmarx.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    

  177.   /*内存数据单位 8bit*/
    

  178.   usart1.dmarx.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;        
    

  179.   /*DMA模式：不断循环*/
    

  180.   usart1.dmarx.DMA_Mode = DMA_Mode_Circular;         
    

  181.   /*优先级：中*/        
    

  182.   usart1.dmarx.DMA_Priority = DMA_Priority_Medium;      
    

  183.   /*禁用FIFO*/
    

  184.   usart1.dmarx.DMA_FIFOMode = DMA_FIFOMode_Disable;        
    

  185.   usart1.dmarx.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;    
    

  186.   /*存储器突发传输 16个节拍*/
    

  187.   usart1.dmarx.DMA_MemoryBurst = DMA_MemoryBurst_Single;    
    

  188.   /*外设突发传输 1个节拍*/
    

  189.   usart1.dmarx.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;    
    

  190.   /*配置DMA2的数据流2*/                   
    

  191.   DMA_Init(DMA2_Stream5, &usart1.dmarx);
    

  192.   
    

  193. //  /*使能DMA*/
    

  194.   DMA_Cmd(DMA2_Stream5, ENABLE);
    

  195.   
    

  196.   /* 等待DMA数据流有效*/
    

  197.   while(DMA_GetCmdStatus(DMA2_Stream5) != ENABLE)
    

  198.   {
    

  199.   }
    


  200. 

  201.   /* 复位初始化DMA数据流 */
    

  202.   DMA_DeInit(DMA2_Stream7);
    


  203. 

  204.   /* 确保DMA数据流复位完成 */
    

  205.   while (DMA_GetCmdStatus(DMA2_Stream7) != DISABLE)  {
    

  206.   }
    


  207. 

  208.   /*usart1 tx对应dma2，通道4，数据流7*/        
    

  209.   usart1.dmatx.DMA_Channel = DMA_Channel_4;  
    

  210.   /*设置DMA源：串口数据寄存器地址*/
    

  211.   usart1.dmatx.DMA_PeripheralBaseAddr =  (USART1_BASE+0x04);         
    

  212.   /*内存地址(要传输的变量的指针)*/
    

  213.   usart1.dmatx.DMA_Memory0BaseAddr = (uint32_t)Usart1_TxBuffer;
    

  214.   /*方向：从内存到外设*/                
    

  215.   usart1.dmatx.DMA_DIR = DMA_DIR_MemoryToPeripheral;        
    

  216.   /*传输大小DMA_BufferSize=SENDBUFF_SIZE*/        
    

  217.   usart1.dmatx.DMA_BufferSize = UARTx_TX_MAX;
    

  218.   /*外设地址不增*/            
    

  219.   usart1.dmatx.DMA_PeripheralInc = DMA_PeripheralInc_Disable; 
    

  220.   /*内存地址自增*/
    

  221.   usart1.dmatx.DMA_MemoryInc = DMA_MemoryInc_Enable;        
    

  222.   /*外设数据单位*/        
    

  223.   usart1.dmatx.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    

  224.   /*内存数据单位 8bit*/
    

  225.   usart1.dmatx.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;        
    

  226.   /*DMA模式：不断循环*/
    

  227.   usart1.dmatx.DMA_Mode = DMA_Mode_Circular;         
    

  228.   /*优先级：中*/        
    

  229.   usart1.dmatx.DMA_Priority = DMA_Priority_Medium;      
    

  230.   /*禁用FIFO*/
    

  231.   usart1.dmatx.DMA_FIFOMode = DMA_FIFOMode_Disable;        
    

  232.   usart1.dmatx.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;    
    

  233.   /*存储器突发传输 16个节拍*/
    

  234.   usart1.dmatx.DMA_MemoryBurst = DMA_MemoryBurst_Single;    
    

  235.   /*外设突发传输 1个节拍*/
    

  236.   usart1.dmatx.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;    
    

  237.   /*配置DMA2的数据流7*/                   
    

  238.   DMA_Init(DMA2_Stream7, &usart1.dmatx);
    

  239. //  
    

  240. //  /*使能DMA*/
    

  241. //  DMA_Cmd(DMA2_Stream7, ENABLE);
    

  242. //  
    

  243. //  /* 等待DMA数据流有效*/
    

  244. //  while(DMA_GetCmdStatus(DMA2_Stream7) != ENABLE)
    

  245. //  {
    

  246. //  } 
    


  247. 


  248. 

  249.         DMA_ITConfig(DMA2_Stream5,DMA_IT_TC,ENABLE);
    

  250.         DMA_ITConfig(DMA2_Stream7,DMA_IT_TC,ENABLE);
    

  251.         // NVIC  
    

  252.         NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;  
    

  253.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;  
    

  254.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;  
    

  255.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;  
    

  256.         NVIC_Init(&NVIC_InitStructure);  
    


  257. 

  258.         NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream7_IRQn;  
    

  259.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;  
    

  260.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;  
    

  261.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;  
    

  262.         NVIC_Init(&NVIC_InitStructure);    
    

  263.   
    

  264.          NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream5_IRQn;  
    

  265.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;  
    

  266.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;  
    

  267.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;  
    

  268.         NVIC_Init(&NVIC_InitStructure);  
    

  269. }
    


  270. 

  271. void Usart1_Txdata(uint8_t *tdata,uint16_t datalen)
    

  272. {
    

  273.         if(datalen == 0)
    

  274.         {
    

  275.                         DMA_SetCurrDataCounter(DMA2_Stream7, UARTx_TX_MAX);        
    

  276.                         return;
    

  277.         }
    

  278.         if((UARTx_TX_SIZE - usart1.TxCounter) >= datalen) //发送空间大于等于发数据
    

  279.         {
    

  280.                 usart1.TxInPtr ->start = &Usart1_TxBuffer[usart1.TxCounter];
    

  281.         }else 
    

  282.         {
    

  283.                 usart1.TxCounter = 0;        //发送空间小于发送数据，清0
    

  284.                 usart1.TxInPtr->start = Usart1_TxBuffer;
    

  285.         }
    

  286.         
    

  287.         
    

  288.         while (DMA_GetCmdStatus(DMA2_Stream7) != DISABLE);        //确保DMA可以被设置
    

  289.         DMA_SetCurrDataCounter(DMA2_Stream7,datalen);                        //设置数据传输长度
    

  290.         
    

  291.         memcpy(usart1.TxInPtr ->start,tdata,datalen);        //数据拷贝
    

  292.         
    

  293.         usart1.TxCounter += datalen;        //统计每次发送量
    

  294.         usart1.TxInPtr ->end = &Usart1_TxBuffer[usart1.TxCounter-1];//标记end位，为下次作准备
    

  295.         DMA2_Stream7->M0AR  = (uint32_t)usart1.TxInPtr->start;
    


  296. 

  297.         usart1.TxInPtr++;
    

  298.         if(usart1.TxInPtr == usart1.TxEndPtr){
    

  299.                 usart1.TxInPtr = &usart1.TxLocation[0];                
    

  300.         }
    

  301. }
    


  302. 

  303. void Usartx_SendArray( USART_TypeDef * pUSARTx, uint8_t *data, uint16_t datalen)
    

  304. {
    

  305.         uint16_t i;
    

  306.         for(i=0;i<datalen;i++)
    

  307.         {
    

  308.             /* 发送一个字节数据到USART */
    

  309.             pUSARTx->DR = data[i];                
    

  310.                 while(!(pUSARTx->SR & USART_FLAG_TXE) );
    

  311.         }
    

  312.         while(!USART_GetFlagStatus(pUSARTx,USART_FLAG_TC));
    

  313. }
    


  314. 

  315. void Usartx_SendStr( USART_TypeDef * pUSARTx, const char *SendStr)
    

  316. {
    

  317.         while(*SendStr != '\0')
    

  318.         {
    

  319.             /* 发送一个字节数据到USART */
    

  320.           // pUSARTx->DR = *SendStr;                
    

  321.                 USART_SendData(pUSARTx,*SendStr);
    

  322.                 //while(!USART_GetFlagStatus(pUSARTx,USART_FLAG_TXE));
    

  323.                 while(!(pUSARTx->SR & USART_FLAG_TXE) );
    

  324.                 SendStr++;
    

  325.         }
    

  326.         while(!USART_GetFlagStatus(pUSARTx,USART_FLAG_TC));
    

  327. }
    


  328. 

  329. //uint8_t tempbuff[256];
    

  330. //void u1_printf(char *fmt, ...)
    

  331. //{
    


  332. 


  333. 

  334. //        uint16_t i=0;        
    


  335. 

  336. //        va_list ap;
    

  337. //        va_start(ap,fmt);
    

  338. //        
    

  339. //        vsprintf((char *)tempbuff,fmt,ap);
    

  340. //        
    

  341. //        va_end(ap);
    

  342. //        DMA_Cmd(DMA2_Stream7,DISABLE);
    

  343. //        for(i=0;i<strlen((char *)tempbuff);i++)
    

  344. //        {
    

  345. //                while(!USART_GetFlagStatus(USART1,USART_FLAG_TXE));
    

  346. //                USART1->DR = tempbuff[i];
    

  347. //        }
    

  348. //        //while(!USART_GetFlagStatus(USART1,USART_FLAG_TC));
    

  349. //}
    


  350. 


  351. 


  352. 

  353. void USART1_IRQHandler(void)
    

  354. {
    

  355.         //发送中断
    

  356.         if(USART_GetITStatus(USART1,USART_IT_TC) != RESET)
    

  357.         {
    

  358.                 USART_ClearITPendingBit(USART1,USART_IT_TC);
    

  359.                 //usart1.TxState = 0;
    

  360.         }                                
    

  361.         //空闲中断
    

  362.         if(USART_GetITStatus(USART1,USART_IT_IDLE) != RESET)
    

  363.         {                
    

  364.                 
    

  365.                 USART1->SR;                       //清中断
    

  366.                 USART1->DR;                       //清中断        
    

  367.                         
    

  368.                 usart1.RxCounter +=((UARTx_RX_MAX+1)- DMA_GetCurrDataCounter(DMA2_Stream5));
    

  369.                 usart1.RxInPtr->end = &Usart1_RxBuffer[usart1.RxCounter - 1];
    

  370.                 
    

  371.                 usart1.RxInPtr++;
    

  372.                 if(usart1.RxInPtr == usart1.RxEndPtr)
    

  373.                 {
    

  374.                         usart1.RxInPtr = &usart1.RxLocation[0];
    

  375.                 }
    

  376.                 if((UARTx_RX_SIZE - usart1.RxCounter) >= UARTx_RX_MAX){
    

  377.                         usart1.RxInPtr->start = &Usart1_RxBuffer[usart1.RxCounter];         //标记接位置
    

  378.                                                                                 
    

  379.                 }else{
    

  380.                         usart1.RxInPtr->start = Usart1_RxBuffer;
    

  381.                         usart1.RxCounter = 0;        
    

  382.                 }                
    

  383.                 
    

  384.                 DMA_Cmd(DMA2_Stream5, DISABLE);     //关闭DMA
    

  385.                 DMA_SetCurrDataCounter(DMA2_Stream5, UARTx_RX_MAX+1);
    

  386.                 DMA2_Stream5->M0AR = (uint32_t)usart1.RxInPtr->start;
    

  387.                 DMA_Cmd(DMA2_Stream5, ENABLE);     //打开DMA                        
    

  388.         }        
    

  389. }
    


  390. 

  391. void DMA2_Stream7_IRQHandler(void)
    

  392. {
    

  393.         if(DMA_GetITStatus(DMA2_Stream7,DMA_IT_TCIF7)!=RESET)//等待DMA2_Steam7传输完成
    

  394.         {                
    

  395.                 DMA_Cmd(DMA2_Stream7,DISABLE);                                //关闭使能
    

  396.                 DMA_ClearITPendingBit(DMA2_Stream7,DMA_FLAG_TCIF7); //清除DMA2_Steam7传输完成标志        
    

  397.                 
    

  398.                 DMA_SetCurrDataCounter(DMA2_Stream7, UARTx_TX_MAX);                
    

  399.                 usart1.TxState = 0;
    

  400.         }
    

  401.         if(DMA_GetITStatus(DMA2_Stream7,DMA_IT_HTIF7)!=RESET)
    

  402.         {
    

  403.                 DMA_ClearITPendingBit(DMA2_Stream7,DMA_IT_HTIF7);
    

  404.         }
    


  405. 

  406. }
    


  407. 

  408. void DMA2_Stream5_IRQHandler(void)
    

  409. {
    

  410.         if(DMA_GetITStatus(DMA2_Stream5,DMA_IT_TCIF5)!=RESET)//等待DMA2_Steam2传输完成
    

  411.         {
    

  412.                 DMA_ClearITPendingBit(DMA2_Stream5,DMA_FLAG_TCIF5); //清除DMA2_Steam2传输完成标志        
    

  413.                 DMA_Cmd(DMA2_Stream5, ENABLE);   
    

  414.         }
    

  415.         if(DMA_GetITStatus(DMA2_Stream5,DMA_IT_HTIF5)!=RESET)
    

  416.         {
    

  417.                 DMA_ClearITPendingBit(DMA2_Stream5,DMA_FLAG_TCIF7);
    

  418.         }        
    


  419. 

  420. }
    


  421. 

  422. /* 加入以下代码, 支持printf函数, 而不需要选择use MicroLIB */
    


  423. 

  424. #if 1
    

  425. #if (__ARMCC_VERSION >= 6010050)                    /* 使用AC6编译器时 */
    

  426. __asm(".global __use_no_semihosting\n\t");          /* 声明不使用半主机模式 */
    

  427. __asm(".global __ARM_use_no_argv \n\t");            /* AC6下需要声明main函数为无参数格式，否则部分例程可能出现半主机模式 */
    


  428. 

  429. #else
    

  430. /* 使用AC5编译器时, 要在这里定义__FILE 和 不使用半主机模式 */
    

  431. #pragma import(__use_no_semihosting)
    


  432. 

  433. struct __FILE
    

  434. {
    

  435.     int handle;
    

  436.     /* Whatever you require here. If the only file you are using is */
    

  437.     /* standard output using printf() for debugging, no file handling */
    

  438.     /* is required. */
    

  439. };
    


  440. 

  441. #endif
    


  442. 

  443. /* 不使用半主机模式，至少需要重定义_ttywrch\_sys_exit\_sys_command_string函数,以同时兼容AC6和AC5模式 */
    

  444. int _ttywrch(int ch)
    

  445. {
    

  446.     ch = ch;
    

  447.     return ch;
    

  448. }
    


  449. 

  450. /* 定义_sys_exit()以避免使用半主机模式 */
    

  451. void _sys_exit(int x)
    

  452. {
    

  453.     x = x;
    

  454. }
    


  455. 

  456. char *_sys_command_string(char *cmd, int len)
    

  457. {
    

  458.     return NULL;
    

  459. }
    


  460. 

  461. /* FILE 在 stdio.h里面定义. */
    

  462. FILE __stdout;
    


  463. 

  464. /* 重定义fputc函数, printf函数最终会通过调用fputc输出字符串到串口 */
    

  465. int fputc(int ch, FILE *f)
    

  466. {
    

  467.     while ((USART1->SR & 0X40) == 0);               /* 等待上一个字符发送完成 */
    


  468. 

  469.     USART1->DR = (uint8_t)ch;                       /* 将要发送的字符 ch 写入到DR寄存器 */
    

  470.         
    

  471.         
    

  472.     return ch;
    

  473. }
    


  474. 

  475. #endif
    

  476. /***********************************************END*******************************************/
    


  477.
usart.h
复制
  1. #ifndef __USART_H
    

  2. #define __USART_H
    

  3. #include "stm32f4xx.h"
    


  4. 

  5. #include <stdint.h>
    

  6. #include "string.h"
    

  7. #include "signal.h"
    

  8. #include "stdarg.h"
    

  9. #include "stdio.h"
    

  10. #include "stdlib.h"
    

  11. #include <stdbool.h>
    


  12. 

  13. #define UARTx_RX_SIZE   4096                 //接收缓冲区长度
    

  14. #define UARTx_TX_SIZE   4096                //发送缓冲区长度
    

  15. #define UARTx_RX_MAX    1029                        //单次接收最大量
    

  16. #define UARTx_TX_MAX    256                        //单次接收最大量
    

  17. #define SE_PTR_NUM      10                        //se指针对结构体数组长度
    


  18. 


  19. 

  20. typedef struct{
    

  21.     uint8_t *start;                                         //start用于标记起始位置                                                                        
    

  22.     uint8_t *end;                                        //end用于标记结束位置
    

  23. }LCB;                        //se 指针对结构体
    


  24. 

  25. typedef struct{
    

  26.         
    

  27.         
    

  28.         uint16_t RxCounter;        //累计接收数据量
    

  29.         uint16_t TxCounter;
    

  30.         uint16_t TxState;
    

  31.         LCB RxLocation[SE_PTR_NUM];        //se指针对结构体数组
    

  32.         LCB *RxInPtr;                        //IN指针用于标记接收数据
    

  33.         LCB *RxOutPtr;                        //OUT指针用于提取接收的数据
    

  34.         LCB *RxEndPtr;                        ////IN和OUT指针的结尾标志
    

  35.         
    

  36.         LCB TxLocation[SE_PTR_NUM];        //se指针对结构体数组
    

  37.         LCB *TxInPtr;                        //IN指针用于标记发送数据
    

  38.         LCB *TxOutPtr;                        //OUT指针用于提取发送的数据
    

  39.         LCB *TxEndPtr;                        ////IN和OUT指针的结尾标志
    


  40. 

  41.         USART_InitTypeDef usart;
    

  42.         DMA_InitTypeDef  dmatx;        
    

  43.         DMA_InitTypeDef  dmarx;
    

  44.         
    

  45. }Usartx_Control_Block;
    


  46. 

  47. extern uint8_t Usart1_RxBuffer[UARTx_RX_SIZE];      //串口1接收缓冲区
    

  48. extern uint8_t Usart1_TxBuffer[UARTx_TX_SIZE];      //串口1发送缓冲区
    

  49. extern Usartx_Control_Block  usart1;                                                               //串口控制结构体
    


  50. 


  51. 

  52.   
    


  53. 

  54. void USART1_Init(uint32_t bandRate);
    

  55. void USART1_GPIO_Init(void);
    

  56. void USART1_Config_Init(uint32_t bandRate);
    

  57. void USART1_DMA_Init(void);
    

  58. void Usart1_PtrInit(void);
    

  59. void Usart1_Txdata(uint8_t *tdata,uint16_t datalen);
    


  60. 

  61. //void u1_printf(char *fmt, ...);
    

  62. void Usart1_Rx_Data(uint8_t *rdata);
    

  63. void usart1TakeCb(void(*pFunc)(uint8_t *data,uint16_t datalen));
    


  64. 

  65. void usart1_take(void);
    


  66. 


  67. 

  68. void Clearsart3_RxBuffer(void);
    


  69. 

  70. void Usartx_SendStr( USART_TypeDef * pUSARTx, const char *SendStr);
    

  71. void Usartx_SendArray( USART_TypeDef * pUSARTx, uint8_t *data, uint16_t datalen);
    

  72. #endif
    


  73.






回复 赏

举报

相关帖子
zhengshuai888 发表于 2024-4-21 19:25 来自手机 | 显示全部楼层
Y我晕，还要付费才能看啊。
回复 赏

举报

WoodData 发表于 2024-4-21 22:25 | 显示全部楼层
这种IAP都很简单了
回复 赏

举报

 楼主| zero949079783 发表于 2024-4-21 23:14 | 显示全部楼层
WoodData 发表于 2024-4-21 22:25
这种IAP都很简单了

简单但是烦而已
回复 赏

举报

lidi911 发表于 2024-4-22 08:35 来自手机 | 显示全部楼层
除了YModem还有XModem和ZModem
回复 赏

举报

cmyldd 发表于 2024-5-11 10:01 | 显示全部楼层
协议是有许多种的, 原理差不多都一样,用熟哪种就那种
回复 赏

举报

纠结的那些年 发表于 2024-8-31 16:04 | 显示全部楼层
配置STM32的USART串口用于与上位机通信。通常使用的引脚为TX和RX。

回复 赏

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

zero949079783

33

主题

91

帖子

1

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