你的浏览器版本过低，可能导致网站不能正常访问！
为了你能正常使用网站功能，请使用这些浏览器。

st-img
chrome st-img
firefox st-img
safari st-img
ie8及以上

YMODEM协议串口文件传输

[复制链接]
XinLiYF 发布时间：2018-3-6 22:28
YMODEM协议串口文件传输
GitHub仓库：http://github.com/XinLiGitHub/SerialPortYmodem
PS：博文不再更新，后续更新会在GitHub仓库进行。


    串口通过YMODEM协议进行文件传输。程序中涉及到YMODEM协议知识，详细介绍见维基百科[YMODEM](http://en.wikipedia.org/wiki/YMODEM)。

1，开发环境
      1，框架：Qt 5.7.1

      2，编译器：MSVC2015_64bit

      3，IDE：Qt Creator 4.2.0 社区版
      4，操作系统：Windows 10 专业版

2，程序源码
      Ymodem.h文件
  1. /**
  2.   ******************************************************************************
  3.   * @file    Ymodem.h
  4.   * @author  XinLi
  5.   * @version v1.0
  6.   * @date    21-January-2018
  7.   * @brief   Header file for Ymodem.cpp module.
  8.   ******************************************************************************
  9.   * @attention
  10.   *
  11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
  12.   *
  13.   * This program is free software: you can redistribute it and/or modify
  14.   * it under the terms of the GNU General Public License as published by
  15.   * the Free Software Foundation, either version 3 of the License, or
  16.   * (at your option) any later version.
  17.   *
  18.   * This program is distributed in the hope that it will be useful,
  19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21.   * GNU General Public License for more details.
  22.   *
  23.   * You should have received a copy of the GNU General Public License
  24.   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  25.   *
  26.   ******************************************************************************
  27.   */

  29. #ifndef __YMODEM_H
  30. #define __YMODEM_H

  32. /* Header includes -----------------------------------------------------------*/
  33. #include <stdint.h>

  35. /* Macro definitions ---------------------------------------------------------*/
  36. #define YMODEM_PACKET_HEADER    (3)
  37. #define YMODEM_PACKET_TRAILER   (2)
  38. #define YMODEM_PACKET_OVERHEAD  (YMODEM_PACKET_HEADER + YMODEM_PACKET_TRAILER)
  39. #define YMODEM_PACKET_SIZE      (128)
  40. #define YMODEM_PACKET_1K_SIZE   (1024)

  42. #define YMODEM_CODE_CAN_NUMBER  (5)

  44. /* Type definitions ----------------------------------------------------------*/
  45. class Ymodem
  46. {
  47. public:
  48.   enum Code
  49.   {
  50.     CodeNone = 0x00,
  51.     CodeSoh  = 0x01,
  52.     CodeStx  = 0x02,
  53.     CodeEot  = 0x04,
  54.     CodeAck  = 0x06,
  55.     CodeNak  = 0x15,
  56.     CodeCan  = 0x18,
  57.     CodeC    = 0x43,
  58.     CodeA1   = 0x41,
  59.     CodeA2   = 0x61
  60.   };

  62.   enum Stage
  63.   {
  64.     StageNone,
  65.     StageEstablishing,
  66.     StageEstablished,
  67.     StageTransmitting,
  68.     StageFinishing,
  69.     StageFinished
  70.   };

  72.   enum Status
  73.   {
  74.     StatusEstablish,
  75.     StatusTransmit,
  76.     StatusFinish,
  77.     StatusAbort,
  78.     StatusTimeout,
  79.     StatusError
  80.   };

  82.   Ymodem(uint32_t timeDivide = 499, uint32_t timeMax = 5, uint32_t errorMax = 999);

  84.   void setTimeDivide(uint32_t timeDivide);
  85.   uint32_t getTimeDivide();

  87.   void setTimeMax(uint32_t timeMax);
  88.   uint32_t getTimeMax();

  90.   void setErrorMax(uint32_t errorMax);
  91.   uint32_t getErrorMax();

  93.   void receive();
  94.   void transmit();
  95.   void abort();

  97. private:
  98.   Code receivePacket();

  100.   void receiveStageNone();
  101.   void receiveStageEstablishing();
  102.   void receiveStageEstablished();
  103.   void receiveStageTransmitting();
  104.   void receiveStageFinishing();
  105.   void receiveStageFinished();

  107.   void transmitStageNone();
  108.   void transmitStageEstablishing();
  109.   void transmitStageEstablished();
  110.   void transmitStageTransmitting();
  111.   void transmitStageFinishing();
  112.   void transmitStageFinished();

  114.   uint16_t crc16(uint8_t *buff, uint32_t len);

  116.   virtual Code callback(Status status, uint8_t *buff, uint32_t *len) = 0;

  118.   virtual uint32_t read(uint8_t *buff, uint32_t len)  = 0;
  119.   virtual uint32_t write(uint8_t *buff, uint32_t len) = 0;

  121.   uint32_t timeDivide;
  122.   uint32_t timeMax;
  123.   uint32_t errorMax;

  125.   uint32_t timeCount;
  126.   uint32_t errorCount;
  127.   uint8_t  dataCount;

  129.   Code  code;
  130.   Stage stage;

  132.   uint8_t  rxBuffer[YMODEM_PACKET_1K_SIZE + YMODEM_PACKET_OVERHEAD];
  133.   uint8_t  txBuffer[YMODEM_PACKET_1K_SIZE + YMODEM_PACKET_OVERHEAD];
  134.   uint32_t rxLength;
  135.   uint32_t txLength;
  136. };

  138. /* Variable declarations -----------------------------------------------------*/
  139. /* Variable definitions ------------------------------------------------------*/
  140. /* Function declarations -----------------------------------------------------*/
  141. /* Function definitions ------------------------------------------------------*/

  143. #endif /* __YMODEM_H */
复制代码

      Ymodem.cpp文件
  1. /**
  2.   ******************************************************************************
  3.   * @file    Ymodem.cpp
  4.   * @author  XinLi
  5.   * @version v1.0
  6.   * @date    21-January-2018
  7.   * @brief   Ymodem protocol module source file.
  8.   ******************************************************************************
  9.   * @attention
  10.   *
  11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
  12.   *
  13.   * This program is free software: you can redistribute it and/or modify
  14.   * it under the terms of the GNU General Public License as published by
  15.   * the Free Software Foundation, either version 3 of the License, or
  16.   * (at your option) any later version.
  17.   *
  18.   * This program is distributed in the hope that it will be useful,
  19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21.   * GNU General Public License for more details.
  22.   *
  23.   * You should have received a copy of the GNU General Public License
  24.   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  25.   *
  26.   ******************************************************************************
  27.   */

  29. /* Header includes -----------------------------------------------------------*/
  30. #include "Ymodem.h"
  31. #include <string.h>

  33. /* Macro definitions ---------------------------------------------------------*/
  34. /* Type definitions ----------------------------------------------------------*/
  35. /* Variable declarations -----------------------------------------------------*/
  36. /* Variable definitions ------------------------------------------------------*/
  37. /* Function declarations -----------------------------------------------------*/
  38. /* Function definitions ------------------------------------------------------*/

  40. /**
  41.   * @brief  Ymodem constructor.
  42.   * @param  [in] timeDivide: The fractional factor of the time the ymodem is called.
  43.   * @param  [in] timeMax:    The maximum time when calling the ymodem.
  44.   * @param  [in] errorMax:   The maximum error count when calling the ymodem.
  45.   * @note   The longest waiting time = call time / (@timeDivide + 1) * (@timeMax + 1).
  46.   * @return None.
  47.   */
  48. Ymodem::Ymodem(uint32_t timeDivide, uint32_t timeMax, uint32_t errorMax)
  49. {
  50.   this->timeDivide = timeDivide;
  51.   this->timeMax    = timeMax;
  52.   this->errorMax   = errorMax;

  54.   this->timeCount  = 0;
  55.   this->errorCount = 0;
  56.   this->dataCount  = 0;

  58.   this->code       = CodeNone;
  59.   this->stage      = StageNone;
  60. }

  62. /**
  63.   * @brief  Set the fractional factor of the time the ymodem is called.
  64.   * @param  [in] timeDivide: The fractional factor of the time the ymodem is called.
  65.   * @return None.
  66.   */
  67. void Ymodem::setTimeDivide(uint32_t timeDivide)
  68. {
  69.   this->timeDivide = timeDivide;
  70. }

  72. /**
  73.   * @brief  Get the fractional factor of the time the ymodem is called.
  74.   * @param  None.
  75.   * @return The fractional factor of the time the ymodem is called.
  76.   */
  77. uint32_t Ymodem::getTimeDivide()
  78. {
  79.   return timeDivide;
  80. }

  82. /**
  83.   * @brief  Set the maximum time when calling the ymodem.
  84.   * @param  [in] timeMax: The maximum time when calling the ymodem.
  85.   * @return None.
  86.   */
  87. void Ymodem::setTimeMax(uint32_t timeMax)
  88. {
  89.   this->timeMax = timeMax;
  90. }

  92. /**
  93.   * @brief  Get the maximum time when calling the ymodem.
  94.   * @param  None.
  95.   * @return The maximum time when calling the ymodem.
  96.   */
  97. uint32_t Ymodem::getTimeMax()
  98. {
  99.   return timeMax;
  100. }

  102. /**
  103.   * @brief  Set the maximum error count when calling the ymodem.
  104.   * @param  [in] errorMax: The maximum error count when calling the ymodem.
  105.   * @return None.
  106.   */
  107. void Ymodem::setErrorMax(uint32_t errorMax)
  108. {
  109.   this->errorMax = errorMax;
  110. }

  112. /**
  113.   * @brief  Get the maximum error count when calling the ymodem.
  114.   * @param  None.
  115.   * @return The maximum error count when calling the ymodem.
  116.   */
  117. uint32_t Ymodem::getErrorMax()
  118. {
  119.   return errorMax;
  120. }

  122. /**
  123.   * @brief  Ymodem receive.
  124.   * @param  None.
  125.   * @return None.
  126.   */
  127. void Ymodem::receive()
  128. {
  129.   switch(stage)
  130.   {
  131.     case StageNone:
  132.     {
  133.       receiveStageNone();

  135.       break;
  136.     }

  138.     case StageEstablishing:
  139.     {
  140.       receiveStageEstablishing();

  142.       break;
  143.     }

  145.     case StageEstablished:
  146.     {
  147.       receiveStageEstablished();

  149.       break;
  150.     }

  152.     case StageTransmitting:
  153.     {
  154.       receiveStageTransmitting();

  156.       break;
  157.     }

  159.     case StageFinishing:
  160.     {
  161.       receiveStageFinishing();

  163.       break;
  164.     }

  166.     default:
  167.     {
  168.       receiveStageFinished();
  169.     }
  170.   }
  171. }

  173. /**
  174.   * @brief  Ymodem transmit.
  175.   * @param  None.
  176.   * @return None.
  177.   */
  178. void Ymodem::transmit()
  179. {
  180.   switch(stage)
  181.   {
  182.     case StageNone:
  183.     {
  184.       transmitStageNone();

  186.       break;
  187.     }

  189.     case StageEstablishing:
  190.     {
  191.       transmitStageEstablishing();

  193.       break;
  194.     }

  196.     case StageEstablished:
  197.     {
  198.       transmitStageEstablished();

  200.       break;
  201.     }

  203.     case StageTransmitting:
  204.     {
  205.       transmitStageTransmitting();

  207.       break;
  208.     }

  210.     case StageFinishing:
  211.     {
  212.       transmitStageFinishing();

  214.       break;
  215.     }

  217.     default:
  218.     {
  219.       transmitStageFinished();
  220.     }
  221.   }
  222. }

  224. /**
  225.   * @brief  Ymodem abort.
  226.   * @param  None.
  227.   * @return None.
  228.   */
  229. void Ymodem::abort()
  230. {
  231.   timeCount  = 0;
  232.   errorCount = 0;
  233.   dataCount  = 0;
  234.   code       = CodeNone;
  235.   stage      = StageNone;

  237.   for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  238.   {
  239.     txBuffer[txLength] = CodeCan;
  240.   }

  242.   write(txBuffer, txLength);
  243. }

  245. /**
  246.   * @brief  Receives a packet of data.
  247.   * @param  None.
  248.   * @return Packet type.
  249.   */
  250. Ymodem::Code Ymodem::receivePacket()
  251. {
  252.   if(code == CodeNone)
  253.   {
  254.     if(read(&(rxBuffer[0]), 1) > 0)
  255.     {
  256.       if(rxBuffer[0] == CodeSoh)
  257.       {
  258.         uint32_t len = read(&(rxBuffer[1]), YMODEM_PACKET_SIZE + YMODEM_PACKET_OVERHEAD - 1);

  260.         if(len < (YMODEM_PACKET_SIZE + YMODEM_PACKET_OVERHEAD - 1))
  261.         {
  262.           rxLength = len + 1;
  263.           code     = CodeSoh;

  265.           return CodeNone;
  266.         }
  267.         else
  268.         {
  269.           return CodeSoh;
  270.         }
  271.       }
  272.       else if(rxBuffer[0] == CodeStx)
  273.       {
  274.         uint32_t len = read(&(rxBuffer[1]), YMODEM_PACKET_1K_SIZE + YMODEM_PACKET_OVERHEAD - 1);

  276.         if(len < (YMODEM_PACKET_1K_SIZE + YMODEM_PACKET_OVERHEAD - 1))
  277.         {
  278.           rxLength = len + 1;
  279.           code     = CodeStx;

  281.           return CodeNone;
  282.         }
  283.         else
  284.         {
  285.           return CodeStx;
  286.         }
  287.       }
  288.       else
  289.       {
  290.         return (Code)(rxBuffer[0]);
  291.       }
  292.     }
  293.     else
  294.     {
  295.       return CodeNone;
  296.     }
  297.   }
  298.   else
  299.   {
  300.     if(code == CodeSoh)
  301.     {
  302.       uint32_t len = read(&(rxBuffer[rxLength]), YMODEM_PACKET_SIZE + YMODEM_PACKET_OVERHEAD - rxLength);

  304.       if(len < (YMODEM_PACKET_SIZE + YMODEM_PACKET_OVERHEAD - rxLength))
  305.       {
  306.         rxLength += len;

  308.         return CodeNone;
  309.       }
  310.       else
  311.       {
  312.         code = CodeNone;

  314.         return CodeSoh;
  315.       }
  316.     }
  317.     else if(code == CodeStx)
  318.     {
  319.       uint32_t len = read(&(rxBuffer[rxLength]), YMODEM_PACKET_1K_SIZE + YMODEM_PACKET_OVERHEAD - rxLength);

  321.       if(len < (YMODEM_PACKET_1K_SIZE + YMODEM_PACKET_OVERHEAD - rxLength))
  322.       {
  323.         rxLength += len;

  325.         return CodeNone;
  326.       }
  327.       else
  328.       {
  329.         code = CodeNone;

  331.         return CodeStx;
  332.       }
  333.     }
  334.     else
  335.     {
  336.       code = CodeNone;

  338.       return CodeNone;
  339.     }
  340.   }
  341. }

  343. /**
  344.   * @brief  Receive none stage.
  345.   * @param  None.
  346.   * @return None.
  347.   */
  348. void Ymodem::receiveStageNone()
  349. {
  350.   timeCount   = 0;
  351.   errorCount  = 0;
  352.   dataCount   = 0;
  353.   code        = CodeNone;
  354.   stage       = StageEstablishing;
  355.   txBuffer[0] = CodeC;
  356.   txLength    = 1;
  357.   write(txBuffer, txLength);
  358. }

  360. /**
  361.   * @brief  Receive establishing stage.
  362.   * @param  None.
  363.   * @return None.
  364.   */
  365. void Ymodem::receiveStageEstablishing()
  366. {
  367.   switch(receivePacket())
  368.   {
  369.     case CodeSoh:
  370.     {
  371.       uint16_t crc = ((uint16_t)(rxBuffer[YMODEM_PACKET_SIZE + YMODEM_PACKET_OVERHEAD - 2]) << 8) |
  372.                      ((uint16_t)(rxBuffer[YMODEM_PACKET_SIZE + YMODEM_PACKET_OVERHEAD - 1]) << 0);

  374.       if((rxBuffer[1] == 0x00) && (rxBuffer[2] == 0xFF) &&
  375.          (crc == crc16(&(rxBuffer[YMODEM_PACKET_HEADER]), YMODEM_PACKET_SIZE)))
  376.       {
  377.         uint32_t dataLength = YMODEM_PACKET_SIZE;

  379.         if(callback(StatusEstablish, &(rxBuffer[YMODEM_PACKET_HEADER]), &dataLength) == CodeAck)
  380.         {
  381.           timeCount   = 0;
  382.           errorCount  = 0;
  383.           dataCount   = 0;
  384.           code        = CodeNone;
  385.           stage       = StageEstablished;
  386.           txBuffer[0] = CodeAck;
  387.           txBuffer[1] = CodeC;
  388.           txLength    = 2;
  389.           write(txBuffer, txLength);
  390.         }
  391.         else
  392.         {
  393.           timeCount  = 0;
  394.           errorCount = 0;
  395.           dataCount  = 0;
  396.           code       = CodeNone;
  397.           stage      = StageNone;

  399.           for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  400.           {
  401.             txBuffer[txLength] = CodeCan;
  402.           }

  404.           write(txBuffer, txLength);
  405.         }
  406.       }
  407.       else
  408.       {
  409.         errorCount++;

  411.         if(errorCount > errorMax)
  412.         {
  413.           timeCount  = 0;
  414.           errorCount = 0;
  415.           dataCount  = 0;
  416.           code       = CodeNone;
  417.           stage      = StageNone;

  419.           for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  420.           {
  421.             txBuffer[txLength] = CodeCan;
  422.           }

  424.           write(txBuffer, txLength);
  425.           callback(StatusError, NULL, NULL);
  426.         }
  427.         else
  428.         {
  429.           txBuffer[0] = CodeC;
  430.           txLength    = 1;
  431.           write(txBuffer, txLength);
  432.         }
  433.       }

  435.       break;
  436.     }

  438.     case CodeA1:
  439.     case CodeA2:
  440.     case CodeCan:
  441.     {
  442.       timeCount  = 0;
  443.       errorCount = 0;
  444.       dataCount  = 0;
  445.       code       = CodeNone;
  446.       stage      = StageNone;
  447.       callback(StatusAbort, NULL, NULL);

  449.       break;
  450.     }

  452.     default:
  453.     {
  454.       timeCount++;

  456.       if((timeCount / (timeDivide + 1)) > timeMax)
  457.       {
  458.         timeCount  = 0;
  459.         errorCount = 0;
  460.         dataCount  = 0;
  461.         code       = CodeNone;
  462.         stage      = StageNone;

  464.         for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  465.         {
  466.           txBuffer[txLength] = CodeCan;
  467.         }

  469.         write(txBuffer, txLength);
  470.         callback(StatusTimeout, NULL, NULL);
  471.       }
  472.       else if((timeCount % (timeDivide + 1)) == 0)
  473.       {
  474.         txBuffer[0] = CodeC;
  475.         txLength    = 1;
  476.         write(txBuffer, txLength);
  477.       }
  478.     }
  479.   }
  480. }

  482. /**
  483.   * @brief  Receive established stage.
  484.   * @param  None.
  485.   * @return None.
  486.   */
  487. void Ymodem::receiveStageEstablished()
  488. {
  489.   switch(receivePacket())
  490.   {
  491.     case CodeSoh:
  492.     {
  493.       uint16_t crc = ((uint16_t)(rxBuffer[YMODEM_PACKET_SIZE + YMODEM_PACKET_OVERHEAD - 2]) << 8) |
  494.                      ((uint16_t)(rxBuffer[YMODEM_PACKET_SIZE + YMODEM_PACKET_OVERHEAD - 1]) << 0);

  496.       if((rxBuffer[1] == 0x00) && (rxBuffer[2] == 0xFF) &&
  497.          (crc == crc16(&(rxBuffer[YMODEM_PACKET_HEADER]), YMODEM_PACKET_SIZE)))
  498.       {
  499.         errorCount++;

  501.         if(errorCount > errorMax)
  502.         {
  503.           timeCount  = 0;
  504.           errorCount = 0;
  505.           dataCount  = 0;
  506.           code       = CodeNone;
  507.           stage      = StageNone;

  509.           for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  510.           {
  511.             txBuffer[txLength] = CodeCan;
  512.           }

  514.           write(txBuffer, txLength);
  515.           callback(StatusError, NULL, NULL);
  516.         }
  517.         else
  518.         {
  519.           txBuffer[0] = CodeAck;
  520.           txBuffer[1] = CodeC;
  521.           txLength    = 2;
  522.           write(txBuffer, txLength);
  523.         }
  524.       }
  525.       else if((rxBuffer[1] == 0x01) && (rxBuffer[2] == 0xFE) &&
  526.               (crc == crc16(&(rxBuffer[YMODEM_PACKET_HEADER]), YMODEM_PACKET_SIZE)))
  527.       {
  528.         uint32_t dataLength = YMODEM_PACKET_SIZE;

  530.         if(callback(StatusTransmit, &(rxBuffer[YMODEM_PACKET_HEADER]), &dataLength) == CodeAck)
  531.         {
  532.           timeCount   = 0;
  533.           errorCount  = 0;
  534.           dataCount   = 1;
  535.           code        = CodeNone;
  536.           stage       = StageTransmitting;
  537.           txBuffer[0] = CodeAck;
  538.           txLength    = 1;
  539.           write(txBuffer, txLength);
  540.         }
  541.         else
  542.         {
  543.           timeCount  = 0;
  544.           errorCount = 0;
  545.           dataCount  = 0;
  546.           code       = CodeNone;
  547.           stage      = StageNone;

  549.           for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  550.           {
  551.             txBuffer[txLength] = CodeCan;
  552.           }

  554.           write(txBuffer, txLength);
  555.         }
  556.       }
  557.       else
  558.       {
  559.         errorCount++;

  561.         if(errorCount > errorMax)
  562.         {
  563.           timeCount  = 0;
  564.           errorCount = 0;
  565.           dataCount  = 0;
  566.           code       = CodeNone;
  567.           stage      = StageNone;

  569.           for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  570.           {
  571.             txBuffer[txLength] = CodeCan;
  572.           }

  574.           write(txBuffer, txLength);
  575.           callback(StatusError, NULL, NULL);
  576.         }
  577.         else
  578.         {
  579.           txBuffer[0] = CodeNak;
  580.           txLength    = 1;
  581.           write(txBuffer, txLength);
  582.         }
  583.       }

  585.       break;
  586.     }

  588.     case CodeStx:
  589.     {
  590.       uint16_t crc = ((uint16_t)(rxBuffer[YMODEM_PACKET_1K_SIZE + YMODEM_PACKET_OVERHEAD - 2]) << 8) |
  591.                      ((uint16_t)(rxBuffer[YMODEM_PACKET_1K_SIZE + YMODEM_PACKET_OVERHEAD - 1]) << 0);

  593.       if((rxBuffer[1] == 0x01) && (rxBuffer[2] == 0xFE) &&
  594.          (crc == crc16(&(rxBuffer[YMODEM_PACKET_HEADER]), YMODEM_PACKET_1K_SIZE)))
  595.       {
  596.         uint32_t dataLength = YMODEM_PACKET_1K_SIZE;

  598.         if(callback(StatusTransmit, &(rxBuffer[YMODEM_PACKET_HEADER]), &dataLength) == CodeAck)
  599.         {
  600.           timeCount   = 0;
  601.           errorCount  = 0;
  602.           dataCount   = 1;
  603.           code        = CodeNone;
  604.           stage       = StageTransmitting;
  605.           txBuffer[0] = CodeAck;
  606.           txLength    = 1;
  607.           write(txBuffer, txLength);
  608.         }
  609.         else
  610.         {
  611.           timeCount  = 0;
  612.           errorCount = 0;
  613.           dataCount  = 0;
  614.           code       = CodeNone;
  615.           stage      = StageNone;

  617.           for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  618.           {
  619.             txBuffer[txLength] = CodeCan;
  620.           }

  622.           write(txBuffer, txLength);
  623.         }
  624.       }
  625.       else
  626.       {
  627.         errorCount++;

  629.         if(errorCount > errorMax)
  630.         {
  631.           timeCount  = 0;
  632.           errorCount = 0;
  633.           dataCount  = 0;
  634.           code       = CodeNone;
  635.           stage      = StageNone;

  637.           for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  638.           {
  639.             txBuffer[txLength] = CodeCan;
  640.           }

  642.           write(txBuffer, txLength);
  643.           callback(StatusError, NULL, NULL);
  644.         }
  645.         else
  646.         {
  647.           txBuffer[0] = CodeNak;
  648.           txLength    = 1;
  649.           write(txBuffer, txLength);
  650.         }
  651.       }

  653.       break;
  654.     }

  656.     case CodeEot:
  657.     {
  658.       timeCount   = 0;
  659.       errorCount  = 0;
  660.       dataCount   = 0;
  661.       code        = CodeNone;
  662.       stage       = StageFinishing;
  663.       txBuffer[0] = CodeNak;
  664.       txLength    = 1;
  665.       write(txBuffer, txLength);

  667.       break;
  668.     }

  670.     case CodeA1:
  671.     case CodeA2:
  672.     case CodeCan:
  673.     {
  674.       timeCount  = 0;
  675.       errorCount = 0;
  676.       dataCount  = 0;
  677.       code       = CodeNone;
  678.       stage      = StageNone;
  679.       callback(StatusAbort, NULL, NULL);

  681.       break;
  682.     }

  684.     default:
  685.     {
  686.       timeCount++;

  688.       if((timeCount / (timeDivide + 1)) > timeMax)
  689.       {
  690.         timeCount  = 0;
  691.         errorCount = 0;
  692.         dataCount  = 0;
  693.         code       = CodeNone;
  694.         stage      = StageNone;

  696.         for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  697.         {
  698.           txBuffer[txLength] = CodeCan;
  699.         }

  701.         write(txBuffer, txLength);
  702.         callback(StatusError, NULL, NULL);
  703.       }
  704.       else if((timeCount % (timeDivide + 1)) == 0)
  705.       {
  706.         txBuffer[0] = CodeNak;
  707.         txLength    = 1;
  708.         write(txBuffer, txLength);
  709.       }
  710.     }
  711.   }
  712. }

  714. /**
  715.   * @brief  Receive transmitting stage.
  716.   * @param  None.
  717.   * @return None.
  718.   */
  719. void Ymodem::receiveStageTransmitting()
  720. {
  721.   switch(receivePacket())
  722.   {
  723.     case CodeSoh:
  724.     {
  725.       uint16_t crc = ((uint16_t)(rxBuffer[YMODEM_PACKET_SIZE + YMODEM_PACKET_OVERHEAD - 2]) << 8) |
  726.                      ((uint16_t)(rxBuffer[YMODEM_PACKET_SIZE + YMODEM_PACKET_OVERHEAD - 1]) << 0);

  728.       if((rxBuffer[1] == (uint8_t)(dataCount)) && (rxBuffer[2] == (uint8_t)(0xFF - dataCount)) &&
  729.          (crc == crc16(&(rxBuffer[YMODEM_PACKET_HEADER]), YMODEM_PACKET_SIZE)))
  730.       {
  731.         errorCount++;

  733.         if(errorCount > errorMax)
  734.         {
  735.           timeCount  = 0;
  736.           errorCount = 0;
  737.           dataCount  = 0;
  738.           code       = CodeNone;
  739.           stage      = StageNone;

  741.           for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  742.           {
  743.             txBuffer[txLength] = CodeCan;
  744.           }

  746.           write(txBuffer, txLength);
  747.           callback(StatusError, NULL, NULL);
  748.         }
  749.         else
  750.         {
  751.           txBuffer[0] = CodeAck;
  752.           txLength    = 1;
  753.           write(txBuffer, txLength);
  754.         }
  755.       }
  756.       else if((rxBuffer[1] == (uint8_t)(dataCount + 1)) && (rxBuffer[2] == (uint8_t)(0xFE - dataCount)) &&
  757.               (crc == crc16(&(rxBuffer[YMODEM_PACKET_HEADER]), YMODEM_PACKET_SIZE)))
  758.       {
  759.         uint32_t dataLength = YMODEM_PACKET_SIZE;

  761.         if(callback(StatusTransmit, &(rxBuffer[YMODEM_PACKET_HEADER]), &dataLength) == CodeAck)
  762.         {
  763.           timeCount   = 0;
  764.           errorCount  = 0;
  765.           dataCount   = dataCount + 1;
  766.           code        = CodeNone;
  767.           stage       = StageTransmitting;
  768.           txBuffer[0] = CodeAck;
  769.           txLength    = 1;
  770.           write(txBuffer, txLength);
  771.         }
  772.         else
  773.         {
  774.           timeCount  = 0;
  775.           errorCount = 0;
  776.           dataCount  = 0;
  777.           code       = CodeNone;
  778.           stage      = StageNone;

  780.           for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  781.           {
  782.             txBuffer[txLength] = CodeCan;
  783.           }

  785.           write(txBuffer, txLength);
  786.         }
  787.       }
  788.       else
  789.       {
  790.         errorCount++;

  792.         if(errorCount > errorMax)
  793.         {
  794.           timeCount  = 0;
  795.           errorCount = 0;
  796.           dataCount  = 0;
  797.           code       = CodeNone;
  798.           stage      = StageNone;

  800.           for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  801.           {
  802.             txBuffer[txLength] = CodeCan;
  803.           }

  805.           write(txBuffer, txLength);
  806.           callback(StatusError, NULL, NULL);
  807.         }
  808.         else
  809.         {
  810.           txBuffer[0] = CodeNak;
  811.           txLength    = 1;
  812.           write(txBuffer, txLength);
  813.         }
  814.       }

  816.       break;
  817.     }

  819.     case CodeStx:
  820.     {
  821.       uint16_t crc = ((uint16_t)(rxBuffer[YMODEM_PACKET_1K_SIZE + YMODEM_PACKET_OVERHEAD - 2]) << 8) |
  822.                      ((uint16_t)(rxBuffer[YMODEM_PACKET_1K_SIZE + YMODEM_PACKET_OVERHEAD - 1]) << 0);

  824.       if((rxBuffer[1] == (uint8_t)(dataCount)) && (rxBuffer[2] == (uint8_t)(0xFF - dataCount)) &&
  825.          (crc == crc16(&(rxBuffer[YMODEM_PACKET_HEADER]), YMODEM_PACKET_1K_SIZE)))
  826.       {
  827.         errorCount++;

  829.         if(errorCount > errorMax)
  830.         {
  831.           timeCount  = 0;
  832.           errorCount = 0;
  833.           dataCount  = 0;
  834.           code       = CodeNone;
  835.           stage      = StageNone;

  837.           for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  838.           {
  839.             txBuffer[txLength] = CodeCan;
  840.           }

  842.           write(txBuffer, txLength);
  843.           callback(StatusError, NULL, NULL);
  844.         }
  845.         else
  846.         {
  847.           txBuffer[0] = CodeAck;
  848.           txLength    = 1;
  849.           write(txBuffer, txLength);
  850.         }
  851.       }
  852.       else if((rxBuffer[1] == (uint8_t)(dataCount + 1)) && (rxBuffer[2] == (uint8_t)(0xFE - dataCount)) &&
  853.               (crc == crc16(&(rxBuffer[YMODEM_PACKET_HEADER]), YMODEM_PACKET_1K_SIZE)))
  854.       {
  855.         uint32_t dataLength = YMODEM_PACKET_1K_SIZE;

  857.         if(callback(StatusTransmit, &(rxBuffer[YMODEM_PACKET_HEADER]), &dataLength) == CodeAck)
  858.         {
  859.           timeCount   = 0;
  860.           errorCount  = 0;
  861.           dataCount   = dataCount + 1;
  862.           code        = CodeNone;
  863.           stage       = StageTransmitting;
  864.           txBuffer[0] = CodeAck;
  865.           txLength    = 1;
  866.           write(txBuffer, txLength);
  867.         }
  868.         else
  869.         {
  870.           timeCount  = 0;
  871.           errorCount = 0;
  872.           dataCount  = 0;
  873.           code       = CodeNone;
  874.           stage      = StageNone;

  876.           for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  877.           {
  878.             txBuffer[txLength] = CodeCan;
  879.           }

  881.           write(txBuffer, txLength);
  882.         }
  883.       }
  884.       else
  885.       {
  886.         errorCount++;

  888.         if(errorCount > errorMax)
  889.         {
  890.           timeCount  = 0;
  891.           errorCount = 0;
  892.           dataCount  = 0;
  893.           code       = CodeNone;
  894.           stage      = StageNone;

  896.           for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  897.           {
  898.             txBuffer[txLength] = CodeCan;
  899.           }

  901.           write(txBuffer, txLength);
  902.           callback(StatusError, NULL, NULL);
  903.         }
  904.         else
  905.         {
  906.           txBuffer[0] = CodeNak;
  907.           txLength    = 1;
  908.           write(txBuffer, txLength);
  909.         }
  910.       }

  912.       break;
  913.     }

  915.     case CodeEot:
  916.     {
  917.       timeCount   = 0;
  918.       errorCount  = 0;
  919.       dataCount   = 0;
  920.       code        = CodeNone;
  921.       stage       = StageFinishing;
  922.       txBuffer[0] = CodeNak;
  923.       txLength    = 1;
  924.       write(txBuffer, txLength);

  926.       break;
  927.     }

  929.     case CodeA1:
  930.     case CodeA2:
  931.     case CodeCan:
  932.     {
  933.       timeCount  = 0;
  934.       errorCount = 0;
  935.       dataCount  = 0;
  936.       code       = CodeNone;
  937.       stage      = StageNone;
  938.       callback(StatusAbort, NULL, NULL);

  940.       break;
  941.     }

  943.     default:
  944.     {
  945.       timeCount++;

  947.       if((timeCount / (timeDivide + 1)) > timeMax)
  948.       {
  949.         timeCount  = 0;
  950.         errorCount = 0;
  951.         dataCount  = 0;
  952.         code       = CodeNone;
  953.         stage      = StageNone;

  955.         for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  956.         {
  957.           txBuffer[txLength] = CodeCan;
  958.         }

  960.         write(txBuffer, txLength);
  961.         callback(StatusError, NULL, NULL);
  962.       }
  963.       else if((timeCount % (timeDivide + 1)) == 0)
  964.       {
  965.         txBuffer[0] = CodeNak;
  966.         txLength    = 1;
  967.         write(txBuffer, txLength);
  968.       }
  969.     }
  970.   }
  971. }

  973. /**
  974.   * @brief  Receive finishing stage.
  975.   * @param  None.
  976.   * @return None.
  977.   */
  978. void Ymodem::receiveStageFinishing()
  979. {
  980.   switch(receivePacket())
  981.   {
  982.     case CodeEot:
  983.     {
  984.       timeCount   = 0;
  985.       errorCount  = 0;
  986.       dataCount   = 0;
  987.       code        = CodeNone;
  988.       stage       = StageFinished;
  989.       txBuffer[0] = CodeAck;
  990.       txBuffer[1] = CodeC;
  991.       txLength    = 2;
  992.       write(txBuffer, txLength);

  994.       break;
  995.     }

  997.     case CodeA1:
  998.     case CodeA2:
  999.     case CodeCan:
  1000.     {
  1001.       timeCount  = 0;
  1002.       errorCount = 0;
  1003.       dataCount  = 0;
  1004.       code       = CodeNone;
  1005.       stage      = StageNone;
  1006.       callback(StatusAbort, NULL, NULL);

  1008.       break;
  1009.     }

  1011.     default:
  1012.     {
  1013.       timeCount++;

  1015.       if((timeCount / (timeDivide + 1)) > timeMax)
  1016.       {
  1017.         timeCount  = 0;
  1018.         errorCount = 0;
  1019.         dataCount  = 0;
  1020.         code       = CodeNone;
  1021.         stage      = StageNone;

  1023.         for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  1024.         {
  1025.           txBuffer[txLength] = CodeCan;
  1026.         }

  1028.         write(txBuffer, txLength);
  1029.         callback(StatusError, NULL, NULL);
  1030.       }
  1031.       else if((timeCount % (timeDivide + 1)) == 0)
  1032.       {
  1033.         txBuffer[0] = CodeNak;
  1034.         txLength    = 1;
  1035.         write(txBuffer, txLength);
  1036.       }
  1037.     }
  1038.   }
  1039. }

  1041. /**
  1042.   * @brief  Receive finished stage.
  1043.   * @param  None.
  1044.   * @return None.
  1045.   */
  1046. void Ymodem::receiveStageFinished()
  1047. {
  1048.   switch(receivePacket())
  1049.   {
  1050.     case CodeSoh:
  1051.     {
  1052.       uint16_t crc = ((uint16_t)(rxBuffer[YMODEM_PACKET_SIZE + YMODEM_PACKET_OVERHEAD - 2]) << 8) |
  1053.                      ((uint16_t)(rxBuffer[YMODEM_PACKET_SIZE + YMODEM_PACKET_OVERHEAD - 1]) << 0);

  1055.       if((rxBuffer[1] == 0x00) && (rxBuffer[2] == 0xFF) &&
  1056.          (crc == crc16(&(rxBuffer[YMODEM_PACKET_HEADER]), YMODEM_PACKET_SIZE)))
  1057.       {
  1058.         timeCount   = 0;
  1059.         errorCount  = 0;
  1060.         dataCount   = 0;
  1061.         code        = CodeNone;
  1062.         stage       = StageNone;
  1063.         txBuffer[0] = CodeAck;
  1064.         txLength    = 1;
  1065.         write(txBuffer, txLength);
  1066.         callback(StatusFinish, NULL, NULL);
  1067.       }
  1068.       else
  1069.       {
  1070.         errorCount++;

  1072.         if(errorCount > errorMax)
  1073.         {
  1074.           timeCount  = 0;
  1075.           errorCount = 0;
  1076.           dataCount  = 0;
  1077.           code       = CodeNone;
  1078.           stage      = StageNone;

  1080.           for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  1081.           {
  1082.             txBuffer[txLength] = CodeCan;
  1083.           }

  1085.           write(txBuffer, txLength);
  1086.           callback(StatusError, NULL, NULL);
  1087.         }
  1088.         else
  1089.         {
  1090.           txBuffer[0] = CodeNak;
  1091.           txLength    = 1;
  1092.           write(txBuffer, txLength);
  1093.         }
  1094.       }

  1096.       break;
  1097.     }

  1099.     case CodeEot:
  1100.     {
  1101.       errorCount++;

  1103.       if(errorCount > errorMax)
  1104.       {
  1105.         timeCount  = 0;
  1106.         errorCount = 0;
  1107.         dataCount  = 0;
  1108.         code       = CodeNone;
  1109.         stage      = StageNone;

  1111.         for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  1112.         {
  1113.           txBuffer[txLength] = CodeCan;
  1114.         }

  1116.         write(txBuffer, txLength);
  1117.         callback(StatusError, NULL, NULL);
  1118.       }
  1119.       else
  1120.       {
  1121.         txBuffer[0] = CodeAck;
  1122.         txBuffer[1] = CodeC;
  1123.         txLength    = 2;
  1124.         write(txBuffer, txLength);
  1125.       }

  1127.       break;
  1128.     }

  1130.     case CodeA1:
  1131.     case CodeA2:
  1132.     case CodeCan:
  1133.     {
  1134.       timeCount  = 0;
  1135.       errorCount = 0;
  1136.       dataCount  = 0;
  1137.       code       = CodeNone;
  1138.       stage      = StageNone;
  1139.       callback(StatusAbort, NULL, NULL);

  1141.       break;
  1142.     }

  1144.     default:
  1145.     {
  1146.       timeCount++;

  1148.       if((timeCount / (timeDivide + 1)) > timeMax)
  1149.       {
  1150.         timeCount  = 0;
  1151.         errorCount = 0;
  1152.         dataCount  = 0;
  1153.         code       = CodeNone;
  1154.         stage      = StageNone;

  1156.         for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  1157.         {
  1158.           txBuffer[txLength] = CodeCan;
  1159.         }

  1161.         write(txBuffer, txLength);
  1162.         callback(StatusError, NULL, NULL);
  1163.       }
  1164.       else if((timeCount % (timeDivide + 1)) == 0)
  1165.       {
  1166.         txBuffer[0] = CodeNak;
  1167.         txLength    = 1;
  1168.         write(txBuffer, txLength);
  1169.       }
  1170.     }
  1171.   }
  1172. }

  1174. /**
  1175.   * @brief  Transmit none stage.
  1176.   * @param  None.
  1177.   * @return None.
  1178.   */
  1179. void Ymodem::transmitStageNone()
  1180. {
  1181.   timeCount   = 0;
  1182.   errorCount  = 0;
  1183.   dataCount   = 0;
  1184.   code        = CodeNone;
  1185.   stage       = StageEstablishing;
  1186. }

  1188. /**
  1189.   * @brief  Transmit establishing stage.
  1190.   * @param  None.
  1191.   * @return None.
  1192.   */
  1193. void Ymodem::transmitStageEstablishing()
  1194. {
  1195.   switch(receivePacket())
  1196.   {
  1197.     case CodeC:
  1198.     {
  1199.       memset(&(txBuffer[YMODEM_PACKET_HEADER]), NULL, YMODEM_PACKET_SIZE);

  1201.       if(callback(StatusEstablish, &(txBuffer[YMODEM_PACKET_HEADER]), &(txLength)) == CodeAck)
  1202.       {
  1203.         uint16_t crc = crc16(&(txBuffer[YMODEM_PACKET_HEADER]), txLength);

  1205.         timeCount                                       = 0;
  1206.         errorCount                                      = 0;
  1207.         dataCount                                       = 0;
  1208.         code                                            = CodeNone;
  1209.         stage                                           = StageEstablished;
  1210.         txBuffer[0]                                     = CodeSoh;
  1211.         txBuffer[1]                                     = 0x00;
  1212.         txBuffer[2]                                     = 0xFF;
  1213.         txBuffer[txLength + YMODEM_PACKET_OVERHEAD - 2] = (uint8_t)(crc >> 8);
  1214.         txBuffer[txLength + YMODEM_PACKET_OVERHEAD - 1] = (uint8_t)(crc >> 0);
  1215.         txLength                                        = txLength + YMODEM_PACKET_OVERHEAD;
  1216.         write(txBuffer, txLength);
  1217.       }
  1218.       else
  1219.       {
  1220.         timeCount  = 0;
  1221.         errorCount = 0;
  1222.         dataCount  = 0;
  1223.         code       = CodeNone;
  1224.         stage      = StageNone;

  1226.         for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  1227.         {
  1228.           txBuffer[txLength] = CodeCan;
  1229.         }

  1231.         write(txBuffer, txLength);
  1232.       }

  1234.       break;
  1235.     }

  1237.     case CodeA1:
  1238.     case CodeA2:
  1239.     case CodeCan:
  1240.     {
  1241.       timeCount  = 0;
  1242.       errorCount = 0;
  1243.       dataCount  = 0;
  1244.       code       = CodeNone;
  1245.       stage      = StageNone;
  1246.       callback(StatusAbort, NULL, NULL);

  1248.       break;
  1249.     }

  1251.     default:
  1252.     {
  1253.       timeCount++;

  1255.       if((timeCount / (timeDivide + 1)) > timeMax)
  1256.       {
  1257.         timeCount  = 0;
  1258.         errorCount = 0;
  1259.         dataCount  = 0;
  1260.         code       = CodeNone;
  1261.         stage      = StageNone;

  1263.         for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  1264.         {
  1265.           txBuffer[txLength] = CodeCan;
  1266.         }

  1268.         write(txBuffer, txLength);
  1269.         callback(StatusTimeout, NULL, NULL);
  1270.       }
  1271.     }
  1272.   }
  1273. }

  1275. /**
  1276.   * @brief  Transmit established stage.
  1277.   * @param  None.
  1278.   * @return None.
  1279.   */
  1280. void Ymodem::transmitStageEstablished()
  1281. {
  1282.   switch(receivePacket())
  1283.   {
  1284.     case CodeNak:
  1285.     {
  1286.       errorCount++;

  1288.       if(errorCount > errorMax)
  1289.       {
  1290.         timeCount  = 0;
  1291.         errorCount = 0;
  1292.         dataCount  = 0;
  1293.         code       = CodeNone;
  1294.         stage      = StageNone;

  1296.         for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  1297.         {
  1298.           txBuffer[txLength] = CodeCan;
  1299.         }

  1301.         write(txBuffer, txLength);
  1302.         callback(StatusError, NULL, NULL);
  1303.       }
  1304.       else
  1305.       {
  1306.         write(txBuffer, txLength);
  1307.       }

  1309.       break;
  1310.     }

  1312.     case CodeC:
  1313.     {
  1314.       errorCount++;

  1316.       if(errorCount > errorMax)
  1317.       {
  1318.         timeCount  = 0;
  1319.         errorCount = 0;
  1320.         dataCount  = 0;
  1321.         code       = CodeNone;
  1322.         stage      = StageNone;

  1324.         for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  1325.         {
  1326.           txBuffer[txLength] = CodeCan;
  1327.         }

  1329.         write(txBuffer, txLength);
  1330.         callback(StatusError, NULL, NULL);
  1331.       }
  1332.       else
  1333.       {
  1334.         timeCount  = 0;
  1335.         errorCount = 0;
  1336.         dataCount  = dataCount;
  1337.         code       = CodeNone;
  1338.         stage      = (Stage)(stage + dataCount);
  1339.         write(txBuffer, txLength);
  1340.       }

  1342.       break;
  1343.     }

  1345.     case CodeAck:
  1346.     {
  1347.       memset(&(txBuffer[YMODEM_PACKET_HEADER]), NULL, YMODEM_PACKET_1K_SIZE);

  1349.       switch(callback(StatusTransmit, &(txBuffer[YMODEM_PACKET_HEADER]), &(txLength)))
  1350.       {
  1351.         case CodeAck:
  1352.         {
  1353.           uint16_t crc = crc16(&(txBuffer[YMODEM_PACKET_HEADER]), txLength);

  1355.           timeCount                                       = 0;
  1356.           errorCount                                      = 0;
  1357.           dataCount                                       = 1;
  1358.           code                                            = CodeNone;
  1359.           stage                                           = StageEstablished;
  1360.           txBuffer[0]                                     = txLength > YMODEM_PACKET_SIZE ? CodeStx : CodeSoh;
  1361.           txBuffer[1]                                     = 0x01;
  1362.           txBuffer[2]                                     = 0xFE;
  1363.           txBuffer[txLength + YMODEM_PACKET_OVERHEAD - 2] = (uint8_t)(crc >> 8);
  1364.           txBuffer[txLength + YMODEM_PACKET_OVERHEAD - 1] = (uint8_t)(crc >> 0);
  1365.           txLength                                        = txLength + YMODEM_PACKET_OVERHEAD;

  1367.           break;
  1368.         }

  1370.         case CodeEot:
  1371.         {
  1372.           timeCount   = 0;
  1373.           errorCount  = 0;
  1374.           dataCount   = 2;
  1375.           code        = CodeNone;
  1376.           stage       = StageEstablished;
  1377.           txBuffer[0] = CodeEot;
  1378.           txLength    = 1;
  1379.           write(txBuffer, txLength);

  1381.           break;
  1382.         }

  1384.         default:
  1385.         {
  1386.           timeCount  = 0;
  1387.           errorCount = 0;
  1388.           dataCount  = 0;
  1389.           code       = CodeNone;
  1390.           stage      = StageNone;

  1392.           for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  1393.           {
  1394.             txBuffer[txLength] = CodeCan;
  1395.           }

  1397.           write(txBuffer, txLength);
  1398.         }
  1399.       }

  1401.       break;
  1402.     }

  1404.     case CodeA1:
  1405.     case CodeA2:
  1406.     case CodeCan:
  1407.     {
  1408.       timeCount  = 0;
  1409.       errorCount = 0;
  1410.       dataCount  = 0;
  1411.       code       = CodeNone;
  1412.       stage      = StageNone;
  1413.       callback(StatusAbort, NULL, NULL);

  1415.       break;
  1416.     }

  1418.     default:
  1419.     {
  1420.       timeCount++;

  1422.       if((timeCount / (timeDivide + 1)) > timeMax)
  1423.       {
  1424.         timeCount  = 0;
  1425.         errorCount = 0;
  1426.         dataCount  = 0;
  1427.         code       = CodeNone;
  1428.         stage      = StageNone;

  1430.         for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  1431.         {
  1432.           txBuffer[txLength] = CodeCan;
  1433.         }

  1435.         write(txBuffer, txLength);
  1436.         callback(StatusError, NULL, NULL);
  1437.       }
  1438.       else if((timeCount % (timeDivide + 1)) == 0)
  1439.       {
  1440.         write(txBuffer, txLength);
  1441.       }
  1442.     }
  1443.   }
  1444. }

  1446. /**
  1447.   * @brief  Transmit transmitting stage.
  1448.   * @param  None.
  1449.   * @return None.
  1450.   */
  1451. void Ymodem::transmitStageTransmitting()
  1452. {
  1453.   switch(receivePacket())
  1454.   {
  1455.     case CodeNak:
  1456.     {
  1457.       errorCount++;

  1459.       if(errorCount > errorMax)
  1460.       {
  1461.         timeCount  = 0;
  1462.         errorCount = 0;
  1463.         dataCount  = 0;
  1464.         code       = CodeNone;
  1465.         stage      = StageNone;

  1467.         for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  1468.         {
  1469.           txBuffer[txLength] = CodeCan;
  1470.         }

  1472.         write(txBuffer, txLength);
  1473.         callback(StatusError, NULL, NULL);
  1474.       }
  1475.       else
  1476.       {
  1477.         write(txBuffer, txLength);
  1478.       }

  1480.       break;
  1481.     }

  1483.     case CodeAck:
  1484.     {
  1485.       memset(&(txBuffer[YMODEM_PACKET_HEADER]), NULL, YMODEM_PACKET_1K_SIZE);

  1487.       switch(callback(StatusTransmit, &(txBuffer[YMODEM_PACKET_HEADER]), &(txLength)))
  1488.       {
  1489.         case CodeAck:
  1490.         {
  1491.           uint16_t crc = crc16(&(txBuffer[YMODEM_PACKET_HEADER]), txLength);

  1493.           timeCount                                       = 0;
  1494.           errorCount                                      = 0;
  1495.           dataCount                                       = dataCount + 1;
  1496.           code                                            = CodeNone;
  1497.           stage                                           = StageTransmitting;
  1498.           txBuffer[0]                                     = txLength > YMODEM_PACKET_SIZE ? CodeStx : CodeSoh;
  1499.           txBuffer[1]                                     = dataCount;
  1500.           txBuffer[2]                                     = 0xFF - dataCount;
  1501.           txBuffer[txLength + YMODEM_PACKET_OVERHEAD - 2] = (uint8_t)(crc >> 8);
  1502.           txBuffer[txLength + YMODEM_PACKET_OVERHEAD - 1] = (uint8_t)(crc >> 0);
  1503.           txLength                                        = txLength + YMODEM_PACKET_OVERHEAD;
  1504.           write(txBuffer, txLength);

  1506.           break;
  1507.         }

  1509.         case CodeEot:
  1510.         {
  1511.           timeCount   = 0;
  1512.           errorCount  = 0;
  1513.           dataCount   = 0;
  1514.           code        = CodeNone;
  1515.           stage       = StageFinishing;
  1516.           txBuffer[0] = CodeEot;
  1517.           txLength    = 1;
  1518.           write(txBuffer, txLength);

  1520.           break;
  1521.         }

  1523.         default:
  1524.         {
  1525.           timeCount  = 0;
  1526.           errorCount = 0;
  1527.           dataCount  = 0;
  1528.           code       = CodeNone;
  1529.           stage      = StageNone;

  1531.           for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  1532.           {
  1533.             txBuffer[txLength] = CodeCan;
  1534.           }

  1536.           write(txBuffer, txLength);
  1537.         }
  1538.       }

  1540.       break;
  1541.     }

  1543.     case CodeA1:
  1544.     case CodeA2:
  1545.     case CodeCan:
  1546.     {
  1547.       timeCount  = 0;
  1548.       errorCount = 0;
  1549.       dataCount  = 0;
  1550.       code       = CodeNone;
  1551.       stage      = StageNone;
  1552.       callback(StatusAbort, NULL, NULL);

  1554.       break;
  1555.     }

  1557.     default:
  1558.     {
  1559.       timeCount++;

  1561.       if((timeCount / (timeDivide + 1)) > timeMax)
  1562.       {
  1563.         timeCount  = 0;
  1564.         errorCount = 0;
  1565.         dataCount  = 0;
  1566.         code       = CodeNone;
  1567.         stage      = StageNone;

  1569.         for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  1570.         {
  1571.           txBuffer[txLength] = CodeCan;
  1572.         }

  1574.         write(txBuffer, txLength);
  1575.         callback(StatusError, NULL, NULL);
  1576.       }
  1577.       else if((timeCount % (timeDivide + 1)) == 0)
  1578.       {
  1579.         write(txBuffer, txLength);
  1580.       }
  1581.     }
  1582.   }
  1583. }

  1585. /**
  1586.   * @brief  Transmit finishing stage.
  1587.   * @param  None.
  1588.   * @return None.
  1589.   */
  1590. void Ymodem::transmitStageFinishing()
  1591. {
  1592.   switch(receivePacket())
  1593.   {
  1594.     case CodeNak:
  1595.     {
  1596.       timeCount   = 0;
  1597.       errorCount  = 0;
  1598.       dataCount   = 0;
  1599.       code        = CodeNone;
  1600.       stage       = StageFinishing;
  1601.       txBuffer[0] = CodeEot;
  1602.       txLength    = 1;
  1603.       write(txBuffer, txLength);

  1605.       break;
  1606.     }

  1608.     case CodeC:
  1609.     {
  1610.       memset(&(txBuffer[YMODEM_PACKET_HEADER]), NULL, YMODEM_PACKET_SIZE);
  1611.       uint16_t crc = crc16(&(txBuffer[YMODEM_PACKET_HEADER]), YMODEM_PACKET_SIZE);

  1613.       timeCount                                                 = 0;
  1614.       errorCount                                                = 0;
  1615.       dataCount                                                 = 0;
  1616.       code                                                      = CodeNone;
  1617.       stage                                                     = StageFinished;
  1618.       txBuffer[0]                                               = CodeSoh;
  1619.       txBuffer[1]                                               = 0x00;
  1620.       txBuffer[2]                                               = 0xFF;
  1621.       txBuffer[YMODEM_PACKET_SIZE + YMODEM_PACKET_OVERHEAD - 2] = (uint8_t)(crc >> 8);
  1622.       txBuffer[YMODEM_PACKET_SIZE + YMODEM_PACKET_OVERHEAD - 1] = (uint8_t)(crc >> 0);
  1623.       txLength                                                  = YMODEM_PACKET_SIZE + YMODEM_PACKET_OVERHEAD;
  1624.       write(txBuffer, txLength);

  1626.       break;
  1627.     }

  1629.     case CodeA1:
  1630.     case CodeA2:
  1631.     case CodeCan:
  1632.     {
  1633.       timeCount  = 0;
  1634.       errorCount = 0;
  1635.       dataCount  = 0;
  1636.       code       = CodeNone;
  1637.       stage      = StageNone;
  1638.       callback(StatusAbort, NULL, NULL);

  1640.       break;
  1641.     }

  1643.     default:
  1644.     {
  1645.       timeCount++;

  1647.       if((timeCount / (timeDivide + 1)) > timeMax)
  1648.       {
  1649.         timeCount  = 0;
  1650.         errorCount = 0;
  1651.         dataCount  = 0;
  1652.         code       = CodeNone;
  1653.         stage      = StageNone;

  1655.         for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  1656.         {
  1657.           txBuffer[txLength] = CodeCan;
  1658.         }

  1660.         write(txBuffer, txLength);
  1661.         callback(StatusError, NULL, NULL);
  1662.       }
  1663.       else if((timeCount % (timeDivide + 1)) == 0)
  1664.       {
  1665.         write(txBuffer, txLength);
  1666.       }
  1667.     }
  1668.   }
  1669. }

  1671. /**
  1672.   * @brief  Transmit finished stage.
  1673.   * @param  None.
  1674.   * @return None.
  1675.   */
  1676. void Ymodem::transmitStageFinished()
  1677. {
  1678.   switch(receivePacket())
  1679.   {
  1680.     case CodeC:
  1681.     case CodeNak:
  1682.     {
  1683.       errorCount++;

  1685.       if(errorCount > errorMax)
  1686.       {
  1687.         timeCount  = 0;
  1688.         errorCount = 0;
  1689.         dataCount  = 0;
  1690.         code       = CodeNone;
  1691.         stage      = StageNone;

  1693.         for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  1694.         {
  1695.           txBuffer[txLength] = CodeCan;
  1696.         }

  1698.         write(txBuffer, txLength);
  1699.         callback(StatusError, NULL, NULL);
  1700.       }
  1701.       else
  1702.       {
  1703.         write(txBuffer, txLength);
  1704.       }

  1706.       break;
  1707.     }

  1709.     case CodeAck:
  1710.     {
  1711.       timeCount  = 0;
  1712.       errorCount = 0;
  1713.       dataCount  = 0;
  1714.       code       = CodeNone;
  1715.       stage      = StageNone;
  1716.       callback(StatusFinish, NULL, NULL);

  1718.       break;
  1719.     }

  1721.     case CodeA1:
  1722.     case CodeA2:
  1723.     case CodeCan:
  1724.     {
  1725.       timeCount  = 0;
  1726.       errorCount = 0;
  1727.       dataCount  = 0;
  1728.       code       = CodeNone;
  1729.       stage      = StageNone;
  1730.       callback(StatusAbort, NULL, NULL);

  1732.       break;
  1733.     }

  1735.     default:
  1736.     {
  1737.       timeCount++;

  1739.       if((timeCount / (timeDivide + 1)) > timeMax)
  1740.       {
  1741.         timeCount  = 0;
  1742.         errorCount = 0;
  1743.         dataCount  = 0;
  1744.         code       = CodeNone;
  1745.         stage      = StageNone;

  1747.         for(txLength = 0; txLength < YMODEM_CODE_CAN_NUMBER; txLength++)
  1748.         {
  1749.           txBuffer[txLength] = CodeCan;
  1750.         }

  1752.         write(txBuffer, txLength);
  1753.         callback(StatusError, NULL, NULL);
  1754.       }
  1755.       else if((timeCount % (timeDivide + 1)) == 0)
  1756.       {
  1757.         write(txBuffer, txLength);
  1758.       }
  1759.     }
  1760.   }
  1761. }

  1763. /**
  1764.   * @brief  Calculate CRC16 checksum.
  1765.   * @param  [in] buff: The data to be calculated.
  1766.   * @param  [in] len:  The length of the data to be calculated.
  1767.   * @return Calculated CRC16 checksum.
  1768.   */
  1769. uint16_t Ymodem::crc16(uint8_t *buff, uint32_t len)
  1770. {
  1771.   uint16_t crc = 0;

  1773.   while(len--)
  1774.   {
  1775.     crc ^= (uint16_t)(*(buff++)) << 8;

  1777.     for(int i = 0; i < 8; i++)
  1778.     {
  1779.       if(crc & 0x8000)
  1780.       {
  1781.         crc = (crc << 1) ^ 0x1021;
  1782.       }
  1783.       else
  1784.       {
  1785.         crc = crc << 1;
  1786.       }
  1787.     }
  1788.   }

  1790.   return crc;
  1791. }
复制代码





赞 收藏 1 评论11 发布时间：2018-3-6 22:28

举报

11个回答
XinLiYF 回答时间：2018-3-6 22:30:39
      YmodemFileReceive.h文件
  1. #ifndef YMODEMFILERECEIVE_H
  2. #define YMODEMFILERECEIVE_H

  4. #include <QFile>
  5. #include <QTimer>
  6. #include <QObject>
  7. #include <QSerialPort>
  8. #include "Ymodem.h"

  10. class YmodemFileReceive : public QObject, public Ymodem
  11. {
  12.     Q_OBJECT

  14. public:
  15.     explicit YmodemFileReceive(QObject *parent = 0);
  16.     ~YmodemFileReceive();

  18.     void setFilePath(const QString &path);

  20.     void setPortName(const QString &name);
  21.     void setPortBaudRate(qint32 baudrate);

  23.     bool startReceive();
  24.     void stopReceive();

  26.     int getReceiveProgress();
  27.     Status getReceiveStatus();

  29. signals:
  30.     void receiveProgress(int progress);
  31.     void receiveStatus(YmodemFileReceive::Status status);

  33. private slots:
  34.     void readTimeOut();
  35.     void writeTimeOut();

  37. private:
  38.     Code callback(Status status, uint8_t *buff, uint32_t *len);

  40.     uint32_t read(uint8_t *buff, uint32_t len);
  41.     uint32_t write(uint8_t *buff, uint32_t len);

  43.     QFile       *file;
  44.     QTimer      *readTimer;
  45.     QTimer      *writeTimer;
  46.     QSerialPort *serialPort;

  48.     int      progress;
  49.     Status   status;
  50.     QString  filePath;
  51.     QString  fileName;
  52.     uint64_t fileSize;
  53.     uint64_t fileCount;
  54. };

  56. #endif // YMODEMFILERECEIVE_H
复制代码

      YmodemFileReceive.cpp文件
  1. #include "YmodemFileReceive.h"

  3. #define READ_TIME_OUT   (10)
  4. #define WRITE_TIME_OUT  (100)

  6. YmodemFileReceive::YmodemFileReceive(QObject *parent) :
  7.     QObject(parent),
  8.     file(new QFile),
  9.     readTimer(new QTimer),
  10.     writeTimer(new QTimer),
  11.     serialPort(new QSerialPort)
  12. {
  13.     setTimeDivide(499);
  14.     setTimeMax(5);
  15.     setErrorMax(999);

  17.     serialPort->setPortName("COM1");
  18.     serialPort->setBaudRate(115200);
  19.     serialPort->setDataBits(QSerialPort::Data8);
  20.     serialPort->setStopBits(QSerialPort::OneStop);
  21.     serialPort->setParity(QSerialPort::NoParity);
  22.     serialPort->setFlowControl(QSerialPort::NoFlowControl);

  24.     connect(readTimer, SIGNAL(timeout()), this, SLOT(readTimeOut()));
  25.     connect(writeTimer, SIGNAL(timeout()), this, SLOT(writeTimeOut()));
  26. }

  28. YmodemFileReceive::~YmodemFileReceive()
  29. {
  30.     delete file;
  31.     delete readTimer;
  32.     delete writeTimer;
  33.     delete serialPort;
  34. }

  36. void YmodemFileReceive::setFilePath(const QString &path)
  37. {
  38.     filePath = path + "/";
  39. }

  41. void YmodemFileReceive::setPortName(const QString &name)
  42. {
  43.     serialPort->setPortName(name);
  44. }

  46. void YmodemFileReceive::setPortBaudRate(qint32 baudrate)
  47. {
  48.     serialPort->setBaudRate(baudrate);
  49. }

  51. bool YmodemFileReceive::startReceive()
  52. {
  53.     progress = 0;
  54.     status   = StatusEstablish;

  56.     if(serialPort->open(QSerialPort::ReadWrite) == true)
  57.     {
  58.         readTimer->start(READ_TIME_OUT);

  60.         return true;
  61.     }
  62.     else
  63.     {
  64.         return false;
  65.     }
  66. }

  68. void YmodemFileReceive::stopReceive()
  69. {
  70.     file->close();
  71.     abort();
  72.     status = StatusAbort;
  73.     writeTimer->start(WRITE_TIME_OUT);
  74. }

  76. int YmodemFileReceive::getReceiveProgress()
  77. {
  78.     return progress;
  79. }

  81. Ymodem::Status YmodemFileReceive::getReceiveStatus()
  82. {
  83.     return status;
  84. }

  86. void YmodemFileReceive::readTimeOut()
  87. {
  88.     readTimer->stop();

  90.     receive();

  92.     if((status == StatusEstablish) || (status == StatusTransmit))
  93.     {
  94.         readTimer->start(READ_TIME_OUT);
  95.     }
  96. }

  98. void YmodemFileReceive::writeTimeOut()
  99. {
  100.     writeTimer->stop();
  101.     serialPort->close();
  102.     receiveStatus(status);
  103. }

  105. Ymodem::Code YmodemFileReceive::callback(Status status, uint8_t *buff, uint32_t *len)
  106. {
  107.     switch(status)
  108.     {
  109.         case StatusEstablish:
  110.         {
  111.             if(buff[0] != 0)
  112.             {
  113.                 int  i         =  0;
  114.                 char name[128] = {0};
  115.                 char size[128] = {0};

  117.                 for(int j = 0; buff[i] != 0; i++, j++)
  118.                 {
  119.                     name[j] = buff[i];
  120.                 }

  122.                 i++;

  124.                 for(int j = 0; buff[i] != 0; i++, j++)
  125.                 {
  126.                     size[j] = buff[i];
  127.                 }

  129.                 fileName  = QString::fromLocal8Bit(name);
  130.                 fileSize  = QString(size).toULongLong();
  131.                 fileCount = 0;

  133.                 file->setFileName(filePath + fileName);

  135.                 if(file->open(QFile::WriteOnly) == true)
  136.                 {
  137.                     YmodemFileReceive::status = StatusEstablish;

  139.                     receiveStatus(StatusEstablish);

  141.                     return CodeAck;
  142.                 }
  143.                 else
  144.                 {
  145.                     YmodemFileReceive::status = StatusError;

  147.                     writeTimer->start(WRITE_TIME_OUT);

  149.                     return CodeCan;
  150.                 }
  151.             }
  152.             else
  153.             {
  154.                 YmodemFileReceive::status = StatusError;

  156.                 writeTimer->start(WRITE_TIME_OUT);

  158.                 return CodeCan;
  159.             }
  160.         }

  162.         case StatusTransmit:
  163.         {
  164.             if((fileSize - fileCount) > *len)
  165.             {
  166.                 file->write((char *)buff, *len);

  168.                 fileCount += *len;
  169.             }
  170.             else
  171.             {
  172.                 file->write((char *)buff, fileSize - fileCount);

  174.                 fileCount += fileSize - fileCount;
  175.             }

  177.             progress = (int)(fileCount * 100 / fileSize);

  179.             YmodemFileReceive::status = StatusTransmit;

  181.             receiveProgress(progress);
  182.             receiveStatus(StatusTransmit);

  184.             return CodeAck;
  185.         }

  187.         case StatusFinish:
  188.         {
  189.             file->close();

  191.             YmodemFileReceive::status = StatusFinish;

  193.             writeTimer->start(WRITE_TIME_OUT);

  195.             return CodeAck;
  196.         }

  198.         case StatusAbort:
  199.         {
  200.             file->close();

  202.             YmodemFileReceive::status = StatusAbort;

  204.             writeTimer->start(WRITE_TIME_OUT);

  206.             return CodeCan;
  207.         }

  209.         case StatusTimeout:
  210.         {
  211.             YmodemFileReceive::status = StatusTimeout;

  213.             writeTimer->start(WRITE_TIME_OUT);

  215.             return CodeCan;
  216.         }

  218.         default:
  219.         {
  220.             file->close();

  222.             YmodemFileReceive::status = StatusError;

  224.             writeTimer->start(WRITE_TIME_OUT);

  226.             return CodeCan;
  227.         }
  228.     }
  229. }

  231. uint32_t YmodemFileReceive::read(uint8_t *buff, uint32_t len)
  232. {
  233.     return serialPort->read((char *)buff, len);
  234. }

  236. uint32_t YmodemFileReceive::write(uint8_t *buff, uint32_t len)
  237. {
  238.     return serialPort->write((char *)buff, len);
  239. }
复制代码





赞 评论
XinLiYF 回答时间：2018-3-6 22:31:26
      YmodemFileTransmit.h文件
  1. #ifndef YMODEMFILETRANSMIT_H
  2. #define YMODEMFILETRANSMIT_H

  4. #include <QFile>
  5. #include <QTimer>
  6. #include <QObject>
  7. #include <QSerialPort>
  8. #include "Ymodem.h"

  10. class YmodemFileTransmit : public QObject, public Ymodem
  11. {
  12.     Q_OBJECT

  14. public:
  15.     explicit YmodemFileTransmit(QObject *parent = 0);
  16.     ~YmodemFileTransmit();

  18.     void setFileName(const QString &name);

  20.     void setPortName(const QString &name);
  21.     void setPortBaudRate(qint32 baudrate);

  23.     bool startTransmit();
  24.     void stopTransmit();

  26.     int getTransmitProgress();
  27.     Status getTransmitStatus();

  29. signals:
  30.     void transmitProgress(int progress);
  31.     void transmitStatus(YmodemFileTransmit::Status status);

  33. private slots:
  34.     void readTimeOut();
  35.     void writeTimeOut();

  37. private:
  38.     Code callback(Status status, uint8_t *buff, uint32_t *len);

  40.     uint32_t read(uint8_t *buff, uint32_t len);
  41.     uint32_t write(uint8_t *buff, uint32_t len);

  43.     QFile       *file;
  44.     QTimer      *readTimer;
  45.     QTimer      *writeTimer;
  46.     QSerialPort *serialPort;

  48.     int      progress;
  49.     Status   status;
  50.     uint64_t fileSize;
  51.     uint64_t fileCount;
  52. };

  54. #endif // YMODEMFILETRANSMIT_H
复制代码

      YmodemFileTransmit.cpp文件
  1. #include "YmodemFileTransmit.h"
  2. #include <QFileInfo>

  4. #define READ_TIME_OUT   (10)
  5. #define WRITE_TIME_OUT  (100)

  7. YmodemFileTransmit::YmodemFileTransmit(QObject *parent) :
  8.     QObject(parent),
  9.     file(new QFile),
  10.     readTimer(new QTimer),
  11.     writeTimer(new QTimer),
  12.     serialPort(new QSerialPort)
  13. {
  14.     setTimeDivide(499);
  15.     setTimeMax(5);
  16.     setErrorMax(999);

  18.     serialPort->setPortName("COM1");
  19.     serialPort->setBaudRate(115200);
  20.     serialPort->setDataBits(QSerialPort::Data8);
  21.     serialPort->setStopBits(QSerialPort::OneStop);
  22.     serialPort->setParity(QSerialPort::NoParity);
  23.     serialPort->setFlowControl(QSerialPort::NoFlowControl);

  25.     connect(readTimer, SIGNAL(timeout()), this, SLOT(readTimeOut()));
  26.     connect(writeTimer, SIGNAL(timeout()), this, SLOT(writeTimeOut()));
  27. }

  29. YmodemFileTransmit::~YmodemFileTransmit()
  30. {
  31.     delete file;
  32.     delete readTimer;
  33.     delete writeTimer;
  34.     delete serialPort;
  35. }

  37. void YmodemFileTransmit::setFileName(const QString &name)
  38. {
  39.     file->setFileName(name);
  40. }

  42. void YmodemFileTransmit::setPortName(const QString &name)
  43. {
  44.     serialPort->setPortName(name);
  45. }

  47. void YmodemFileTransmit::setPortBaudRate(qint32 baudrate)
  48. {
  49.     serialPort->setBaudRate(baudrate);
  50. }

  52. bool YmodemFileTransmit::startTransmit()
  53. {
  54.     progress = 0;
  55.     status   = StatusEstablish;

  57.     if(serialPort->open(QSerialPort::ReadWrite) == true)
  58.     {
  59.         readTimer->start(READ_TIME_OUT);

  61.         return true;
  62.     }
  63.     else
  64.     {
  65.         return false;
  66.     }
  67. }

  69. void YmodemFileTransmit::stopTransmit()
  70. {
  71.     file->close();
  72.     abort();
  73.     status = StatusAbort;
  74.     writeTimer->start(WRITE_TIME_OUT);
  75. }

  77. int YmodemFileTransmit::getTransmitProgress()
  78. {
  79.     return progress;
  80. }

  82. Ymodem::Status YmodemFileTransmit::getTransmitStatus()
  83. {
  84.     return status;
  85. }

  87. void YmodemFileTransmit::readTimeOut()
  88. {
  89.     readTimer->stop();

  91.     transmit();

  93.     if((status == StatusEstablish) || (status == StatusTransmit))
  94.     {
  95.         readTimer->start(READ_TIME_OUT);
  96.     }
  97. }

  99. void YmodemFileTransmit::writeTimeOut()
  100. {
  101.     writeTimer->stop();
  102.     serialPort->close();
  103.     transmitStatus(status);
  104. }

  106. Ymodem::Code YmodemFileTransmit::callback(Status status, uint8_t *buff, uint32_t *len)
  107. {
  108.     switch(status)
  109.     {
  110.         case StatusEstablish:
  111.         {
  112.             if(file->open(QFile::ReadOnly) == true)
  113.             {
  114.                 QFileInfo fileInfo(*file);

  116.                 fileSize  = fileInfo.size();
  117.                 fileCount = 0;

  119.                 strcpy((char *)buff, fileInfo.fileName().toLocal8Bit().data());
  120.                 strcpy((char *)buff + fileInfo.fileName().toLocal8Bit().size() + 1, QByteArray::number(fileInfo.size()).data());

  122.                 *len = YMODEM_PACKET_SIZE;

  124.                 YmodemFileTransmit::status = StatusEstablish;

  126.                 transmitStatus(StatusEstablish);

  128.                 return CodeAck;
  129.             }
  130.             else
  131.             {
  132.                 YmodemFileTransmit::status = StatusError;

  134.                 writeTimer->start(WRITE_TIME_OUT);

  136.                 return CodeCan;
  137.             }
  138.         }

  140.         case StatusTransmit:
  141.         {
  142.             if(fileSize != fileCount)
  143.             {
  144.                 if((fileSize - fileCount) > YMODEM_PACKET_SIZE)
  145.                 {
  146.                     fileCount += file->read((char *)buff, YMODEM_PACKET_1K_SIZE);

  148.                     *len = YMODEM_PACKET_1K_SIZE;
  149.                 }
  150.                 else
  151.                 {
  152.                     fileCount += file->read((char *)buff, YMODEM_PACKET_SIZE);

  154.                     *len = YMODEM_PACKET_SIZE;
  155.                 }

  157.                 progress = (int)(fileCount * 100 / fileSize);

  159.                 YmodemFileTransmit::status = StatusTransmit;

  161.                 transmitProgress(progress);
  162.                 transmitStatus(StatusTransmit);

  164.                 return CodeAck;
  165.             }
  166.             else
  167.             {
  168.                 YmodemFileTransmit::status = StatusTransmit;

  170.                 transmitStatus(StatusTransmit);

  172.                 return CodeEot;
  173.             }
  174.         }

  176.         case StatusFinish:
  177.         {
  178.             file->close();

  180.             YmodemFileTransmit::status = StatusFinish;

  182.             writeTimer->start(WRITE_TIME_OUT);

  184.             return CodeAck;
  185.         }

  187.         case StatusAbort:
  188.         {
  189.             file->close();

  191.             YmodemFileTransmit::status = StatusAbort;

  193.             writeTimer->start(WRITE_TIME_OUT);

  195.             return CodeCan;
  196.         }

  198.         case StatusTimeout:
  199.         {
  200.             YmodemFileTransmit::status = StatusTimeout;

  202.             writeTimer->start(WRITE_TIME_OUT);

  204.             return CodeCan;
  205.         }

  207.         default:
  208.         {
  209.             file->close();

  211.             YmodemFileTransmit::status = StatusError;

  213.             writeTimer->start(WRITE_TIME_OUT);

  215.             return CodeCan;
  216.         }
  217.     }
  218. }

  220. uint32_t YmodemFileTransmit::read(uint8_t *buff, uint32_t len)
  221. {
  222.     return serialPort->read((char *)buff, len);
  223. }

  225. uint32_t YmodemFileTransmit::write(uint8_t *buff, uint32_t len)
  226. {
  227.     return serialPort->write((char *)buff, len);
  228. }
复制代码





赞 评论
XinLiYF 回答时间：2018-3-6 22:32:05
      widget.ui文件
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <ui version="4.0">
  3. <class>Widget</class>
  4. <widget class="QWidget" name="Widget">
  5.   <property name="geometry">
  6.    <rect>
  7.     <x>0</x>
  8.     <y>0</y>
  9.     <width>444</width>
  10.     <height>255</height>
  11.    </rect>
  12.   </property>
  13.   <property name="minimumSize">
  14.    <size>
  15.     <width>444</width>
  16.     <height>255</height>
  17.    </size>
  18.   </property>
  19.   <property name="maximumSize">
  20.    <size>
  21.     <width>444</width>
  22.     <height>255</height>
  23.    </size>
  24.   </property>
  25.   <property name="windowTitle">
  26.    <string>SerialPortYmodem</string>
  27.   </property>
  28.   <layout class="QVBoxLayout" name="verticalLayout_3">
  29.    <item>
  30.     <widget class="QGroupBox" name="groupBox">
  31.      <property name="title">
  32.       <string>串口配置</string>
  33.      </property>
  34.      <layout class="QHBoxLayout" name="horizontalLayout">
  35.       <item>
  36.        <widget class="QLabel" name="label">
  37.         <property name="text">
  38.          <string>端口：</string>
  39.         </property>
  40.        </widget>
  41.       </item>
  42.       <item>
  43.        <widget class="QComboBox" name="comPort">
  44.         <property name="maxVisibleItems">
  45.          <number>12</number>
  46.         </property>
  47.        </widget>
  48.       </item>
  49.       <item>
  50.        <spacer name="horizontalSpacer">
  51.         <property name="orientation">
  52.          <enum>Qt::Horizontal</enum>
  53.         </property>
  54.         <property name="sizeHint" stdset="0">
  55.          <size>
  56.           <width>40</width>
  57.           <height>20</height>
  58.          </size>
  59.         </property>
  60.        </spacer>
  61.       </item>
  62.       <item>
  63.        <widget class="QLabel" name="label_2">
  64.         <property name="text">
  65.          <string>波特率：</string>
  66.         </property>
  67.        </widget>
  68.       </item>
  69.       <item>
  70.        <widget class="QComboBox" name="comBaudRate">
  71.         <property name="currentText">
  72.          <string>115200</string>
  73.         </property>
  74.         <property name="currentIndex">
  75.          <number>3</number>
  76.         </property>
  77.         <property name="maxVisibleItems">
  78.          <number>12</number>
  79.         </property>
  80.         <item>
  81.          <property name="text">
  82.           <string>921600</string>
  83.          </property>
  84.         </item>
  85.         <item>
  86.          <property name="text">
  87.           <string>460800</string>
  88.          </property>
  89.         </item>
  90.         <item>
  91.          <property name="text">
  92.           <string>230400</string>
  93.          </property>
  94.         </item>
  95.         <item>
  96.          <property name="text">
  97.           <string>115200</string>
  98.          </property>
  99.         </item>
  100.         <item>
  101.          <property name="text">
  102.           <string>57600</string>
  103.          </property>
  104.         </item>
  105.         <item>
  106.          <property name="text">
  107.           <string>38400</string>
  108.          </property>
  109.         </item>
  110.         <item>
  111.          <property name="text">
  112.           <string>19200</string>
  113.          </property>
  114.         </item>
  115.         <item>
  116.          <property name="text">
  117.           <string>9600</string>
  118.          </property>
  119.         </item>
  120.         <item>
  121.          <property name="text">
  122.           <string>4800</string>
  123.          </property>
  124.         </item>
  125.         <item>
  126.          <property name="text">
  127.           <string>2400</string>
  128.          </property>
  129.         </item>
  130.         <item>
  131.          <property name="text">
  132.           <string>1200</string>
  133.          </property>
  134.         </item>
  135.        </widget>
  136.       </item>
  137.       <item>
  138.        <spacer name="horizontalSpacer_2">
  139.         <property name="orientation">
  140.          <enum>Qt::Horizontal</enum>
  141.         </property>
  142.         <property name="sizeHint" stdset="0">
  143.          <size>
  144.           <width>40</width>
  145.           <height>20</height>
  146.          </size>
  147.         </property>
  148.        </spacer>
  149.       </item>
  150.       <item>
  151.        <widget class="QPushButton" name="comButton">
  152.         <property name="text">
  153.          <string>打开</string>
  154.         </property>
  155.        </widget>
  156.       </item>
  157.      </layout>
  158.     </widget>
  159.    </item>
  160.    <item>
  161.     <widget class="QGroupBox" name="groupBox_2">
  162.      <property name="title">
  163.       <string>文件发送</string>
  164.      </property>
  165.      <layout class="QVBoxLayout" name="verticalLayout">
  166.       <item>
  167.        <layout class="QHBoxLayout" name="horizontalLayout_2">
  168.         <item>
  169.          <widget class="QLabel" name="label_3">
  170.           <property name="text">
  171.            <string>文件路径：</string>
  172.           </property>
  173.          </widget>
  174.         </item>
  175.         <item>
  176.          <widget class="QLineEdit" name="transmitPath">
  177.           <property name="readOnly">
  178.            <bool>true</bool>
  179.           </property>
  180.          </widget>
  181.         </item>
  182.         <item>
  183.          <widget class="QPushButton" name="transmitBrowse">
  184.           <property name="enabled">
  185.            <bool>false</bool>
  186.           </property>
  187.           <property name="text">
  188.            <string>浏览...</string>
  189.           </property>
  190.          </widget>
  191.         </item>
  192.         <item>
  193.          <widget class="QPushButton" name="transmitButton">
  194.           <property name="enabled">
  195.            <bool>false</bool>
  196.           </property>
  197.           <property name="text">
  198.            <string>发送</string>
  199.           </property>
  200.          </widget>
  201.         </item>
  202.        </layout>
  203.       </item>
  204.       <item>
  205.        <layout class="QHBoxLayout" name="horizontalLayout_3">
  206.         <item>
  207.          <widget class="QLabel" name="label_5">
  208.           <property name="text">
  209.            <string>传输进度：</string>
  210.           </property>
  211.          </widget>
  212.         </item>
  213.         <item>
  214.          <widget class="QProgressBar" name="transmitProgress">
  215.           <property name="value">
  216.            <number>0</number>
  217.           </property>
  218.          </widget>
  219.         </item>
  220.        </layout>
  221.       </item>
  222.      </layout>
  223.     </widget>
  224.    </item>
  225.    <item>
  226.     <widget class="QGroupBox" name="groupBox_3">
  227.      <property name="title">
  228.       <string>文件接收</string>
  229.      </property>
  230.      <layout class="QVBoxLayout" name="verticalLayout_2">
  231.       <item>
  232.        <layout class="QHBoxLayout" name="horizontalLayout_4">
  233.         <item>
  234.          <widget class="QLabel" name="label_4">
  235.           <property name="text">
  236.            <string>文件路径：</string>
  237.           </property>
  238.          </widget>
  239.         </item>
  240.         <item>
  241.          <widget class="QLineEdit" name="receivePath">
  242.           <property name="readOnly">
  243.            <bool>true</bool>
  244.           </property>
  245.          </widget>
  246.         </item>
  247.         <item>
  248.          <widget class="QPushButton" name="receiveBrowse">
  249.           <property name="enabled">
  250.            <bool>false</bool>
  251.           </property>
  252.           <property name="text">
  253.            <string>浏览...</string>
  254.           </property>
  255.          </widget>
  256.         </item>
  257.         <item>
  258.          <widget class="QPushButton" name="receiveButton">
  259.           <property name="enabled">
  260.            <bool>false</bool>
  261.           </property>
  262.           <property name="text">
  263.            <string>接收</string>
  264.           </property>
  265.          </widget>
  266.         </item>
  267.        </layout>
  268.       </item>
  269.       <item>
  270.        <layout class="QHBoxLayout" name="horizontalLayout_5">
  271.         <item>
  272.          <widget class="QLabel" name="label_6">
  273.           <property name="text">
  274.            <string>传输进度：</string>
  275.           </property>
  276.          </widget>
  277.         </item>
  278.         <item>
  279.          <widget class="QProgressBar" name="receiveProgress">
  280.           <property name="value">
  281.            <number>0</number>
  282.           </property>
  283.          </widget>
  284.         </item>
  285.        </layout>
  286.       </item>
  287.      </layout>
  288.     </widget>
  289.    </item>
  290.   </layout>
  291. </widget>
  292. <layoutdefault spacing="6" margin="11"/>
  293. <resources/>
  294. <connections/>
  295. </ui>
复制代码

      widget.h文件
  1. #ifndef WIDGET_H
  2. #define WIDGET_H

  4. #include <QWidget>
  5. #include "YmodemFileTransmit.h"
  6. #include "YmodemFileReceive.h"

  8. namespace Ui {
  9. class Widget;
  10. }

  12. class Widget : public QWidget
  13. {
  14.     Q_OBJECT

  16. public:
  17.     explicit Widget(QWidget *parent = 0);
  18.     ~Widget();

  20. private slots:
  21.     void on_comButton_clicked();
  22.     void on_transmitBrowse_clicked();
  23.     void on_receiveBrowse_clicked();
  24.     void on_transmitButton_clicked();
  25.     void on_receiveButton_clicked();
  26.     void transmitProgress(int progress);
  27.     void receiveProgress(int progress);
  28.     void transmitStatus(YmodemFileTransmit::Status status);
  29.     void receiveStatus(YmodemFileReceive::Status status);

  31. private:
  32.     Ui::Widget *ui;
  33.     QSerialPort *serialPort;
  34.     YmodemFileTransmit *ymodemFileTransmit;
  35.     YmodemFileReceive *ymodemFileReceive;

  37.     bool transmitButtonStatus;
  38.     bool receiveButtonStatus;
  39. };

  41. #endif // WIDGET_H
复制代码

      widget.cpp文件
  1. #include "widget.h"
  2. #include "ui_widget.h"
  3. #include <QMessageBox>
  4. #include <QFileDialog>
  5. #include <QSerialPortInfo>

  7. Widget::Widget(QWidget *parent) :
  8.     QWidget(parent),
  9.     ui(new Ui::Widget),
  10.     serialPort(new QSerialPort),
  11.     ymodemFileTransmit(new YmodemFileTransmit),
  12.     ymodemFileReceive(new YmodemFileReceive)
  13. {
  14.     transmitButtonStatus = false;
  15.     receiveButtonStatus  = false;

  17.     ui->setupUi(this);

  19.     QSerialPortInfo serialPortInfo;

  21.     foreach(serialPortInfo, QSerialPortInfo::availablePorts())
  22.     {
  23.         ui->comPort->addItem(serialPortInfo.portName());
  24.     }

  26.     serialPort->setPortName("COM1");
  27.     serialPort->setBaudRate(115200);
  28.     serialPort->setDataBits(QSerialPort::Data8);
  29.     serialPort->setStopBits(QSerialPort::OneStop);
  30.     serialPort->setParity(QSerialPort::NoParity);
  31.     serialPort->setFlowControl(QSerialPort::NoFlowControl);

  33.     connect(ymodemFileTransmit, SIGNAL(transmitProgress(int)), this, SLOT(transmitProgress(int)));
  34.     connect(ymodemFileReceive, SIGNAL(receiveProgress(int)), this, SLOT(receiveProgress(int)));

  36.    connect(ymodemFileTransmit,
  37. SIGNAL(transmitStatus(YmodemFileTransmit::Status)), this,
  38. SLOT(transmitStatus(YmodemFileTransmit::Status)));
  39.    
  40. connect(ymodemFileReceive,
  41. SIGNAL(receiveStatus(YmodemFileReceive::Status)), this,
  42. SLOT(receiveStatus(YmodemFileReceive::Status)));
  43. }

  45. Widget::~Widget()
  46. {
  47.     delete ui;
  48.     delete serialPort;
  49.     delete ymodemFileTransmit;
  50.     delete ymodemFileReceive;
  51. }

  53. void Widget::on_comButton_clicked()
  54. {
  55.     static bool button_status = false;

  57.     if(button_status == false)
  58.     {
  59.         serialPort->setPortName(ui->comPort->currentText());
  60.         serialPort->setBaudRate(ui->comBaudRate->currentText().toInt());

  62.         if(serialPort->open(QSerialPort::ReadWrite) == true)
  63.         {
  64.             button_status = true;

  66.             ui->comPort->setDisabled(true);
  67.             ui->comBaudRate->setDisabled(true);
  68.             ui->comButton->setText(u8"关闭串口");

  70.             ui->transmitBrowse->setEnabled(true);
  71.             ui->receiveBrowse->setEnabled(true);

  73.             if(ui->transmitPath->text().isEmpty() != true)
  74.             {
  75.                 ui->transmitButton->setEnabled(true);
  76.             }

  78.             if(ui->receivePath->text().isEmpty() != true)
  79.             {
  80.                 ui->receiveButton->setEnabled(true);
  81.             }
  82.         }
  83.         else
  84.         {
  85.             QMessageBox::warning(this, u8"串口打开失败", u8"请检查串口是否已被占用！", u8"关闭");
  86.         }
  87.     }
  88.     else
  89.     {
  90.         button_status = false;

  92.         serialPort->close();

  94.         ui->comPort->setEnabled(true);
  95.         ui->comBaudRate->setEnabled(true);
  96.         ui->comButton->setText(u8"打开串口");

  98.         ui->transmitBrowse->setDisabled(true);
  99.         ui->transmitButton->setDisabled(true);

  101.         ui->receiveBrowse->setDisabled(true);
  102.         ui->receiveButton->setDisabled(true);
  103.     }
  104. }

  106. void Widget::on_transmitBrowse_clicked()
  107. {
  108.     ui->transmitPath->setText(QFileDialog::getOpenFileName(this, u8"打开文件", ".", u8"任意文件 (*.*)"));

  110.     if(ui->transmitPath->text().isEmpty() != true)
  111.     {
  112.         ui->transmitButton->setEnabled(true);
  113.     }
  114.     else
  115.     {
  116.         ui->transmitButton->setDisabled(true);
  117.     }
  118. }

  120. void Widget::on_receiveBrowse_clicked()
  121. {
  122.     ui->receivePath->setText(QFileDialog::getExistingDirectory(this, u8"选择目录", ".", QFileDialog::ShowDirsOnly));

  124.     if(ui->receivePath->text().isEmpty() != true)
  125.     {
  126.         ui->receiveButton->setEnabled(true);
  127.     }
  128.     else
  129.     {
  130.         ui->receiveButton->setDisabled(true);
  131.     }
  132. }

  134. void Widget::on_transmitButton_clicked()
  135. {
  136.     if(transmitButtonStatus == false)
  137.     {
  138.         serialPort->close();

  140.         ymodemFileTransmit->setFileName(ui->transmitPath->text());
  141.         ymodemFileTransmit->setPortName(ui->comPort->currentText());
  142.         ymodemFileTransmit->setPortBaudRate(ui->comBaudRate->currentText().toInt());

  144.         if(ymodemFileTransmit->startTransmit() == true)
  145.         {
  146.             transmitButtonStatus = true;

  148.             ui->comButton->setDisabled(true);

  150.             ui->receiveBrowse->setDisabled(true);
  151.             ui->receiveButton->setDisabled(true);

  153.             ui->transmitBrowse->setDisabled(true);
  154.             ui->transmitButton->setText(u8"取消");
  155.             ui->transmitProgress->setValue(0);
  156.         }
  157.         else
  158.         {
  159.             QMessageBox::warning(this, u8"失败", u8"文件发送失败！", u8"关闭");
  160.         }
  161.     }
  162.     else
  163.     {
  164.         ymodemFileTransmit->stopTransmit();
  165.     }
  166. }

  168. void Widget::on_receiveButton_clicked()
  169. {
  170.     if(receiveButtonStatus == false)
  171.     {
  172.         serialPort->close();

  174.         ymodemFileReceive->setFilePath(ui->receivePath->text());
  175.         ymodemFileReceive->setPortName(ui->comPort->currentText());
  176.         ymodemFileReceive->setPortBaudRate(ui->comBaudRate->currentText().toInt());

  178.         if(ymodemFileReceive->startReceive() == true)
  179.         {
  180.             receiveButtonStatus = true;

  182.             ui->comButton->setDisabled(true);

  184.             ui->transmitBrowse->setDisabled(true);
  185.             ui->transmitButton->setDisabled(true);

  187.             ui->receiveBrowse->setDisabled(true);
  188.             ui->receiveButton->setText(u8"取消");
  189.             ui->receiveProgress->setValue(0);
  190.         }
  191.         else
  192.         {
  193.             QMessageBox::warning(this, u8"失败", u8"文件接收失败！", u8"关闭");
  194.         }
  195.     }
  196.     else
  197.     {
  198.         ymodemFileReceive->stopReceive();
  199.     }
  200. }

  202. void Widget::transmitProgress(int progress)
  203. {
  204.     ui->transmitProgress->setValue(progress);
  205. }

  207. void Widget::receiveProgress(int progress)
  208. {
  209.     ui->receiveProgress->setValue(progress);
  210. }

  212. void Widget::transmitStatus(Ymodem::Status status)
  213. {
  214.     switch(status)
  215.     {
  216.         case YmodemFileTransmit::StatusEstablish:
  217.         {
  218.             break;
  219.         }

  221.         case YmodemFileTransmit::StatusTransmit:
  222.         {
  223.             break;
  224.         }

  226.         case YmodemFileTransmit::StatusFinish:
  227.         {
  228.             transmitButtonStatus = false;

  230.             ui->comButton->setEnabled(true);

  232.             ui->receiveBrowse->setEnabled(true);

  234.             if(ui->receivePath->text().isEmpty() != true)
  235.             {
  236.                 ui->receiveButton->setEnabled(true);
  237.             }

  239.             ui->transmitBrowse->setEnabled(true);
  240.             ui->transmitButton->setText(u8"发送");

  242.             QMessageBox::warning(this, u8"成功", u8"文件发送成功！", u8"关闭");

  244.             break;
  245.         }

  247.         case YmodemFileTransmit::StatusAbort:
  248.         {
  249.             transmitButtonStatus = false;

  251.             ui->comButton->setEnabled(true);

  253.             ui->receiveBrowse->setEnabled(true);

  255.             if(ui->receivePath->text().isEmpty() != true)
  256.             {
  257.                 ui->receiveButton->setEnabled(true);
  258.             }

  260.             ui->transmitBrowse->setEnabled(true);
  261.             ui->transmitButton->setText(u8"发送");

  263.             QMessageBox::warning(this, u8"失败", u8"文件发送失败！", u8"关闭");

  265.             break;
  266.         }

  268.         case YmodemFileTransmit::StatusTimeout:
  269.         {
  270.             transmitButtonStatus = false;

  272.             ui->comButton->setEnabled(true);

  274.             ui->receiveBrowse->setEnabled(true);

  276.             if(ui->receivePath->text().isEmpty() != true)
  277.             {
  278.                 ui->receiveButton->setEnabled(true);
  279.             }

  281.             ui->transmitBrowse->setEnabled(true);
  282.             ui->transmitButton->setText(u8"发送");

  284.             QMessageBox::warning(this, u8"失败", u8"文件发送失败！", u8"关闭");

  286.             break;
  287.         }

  289.         default:
  290.         {
  291.             transmitButtonStatus = false;

  293.             ui->comButton->setEnabled(true);

  295.             ui->receiveBrowse->setEnabled(true);

  297.             if(ui->receivePath->text().isEmpty() != true)
  298.             {
  299.                 ui->receiveButton->setEnabled(true);
  300.             }

  302.             ui->transmitBrowse->setEnabled(true);
  303.             ui->transmitButton->setText(u8"发送");

  305.             QMessageBox::warning(this, u8"失败", u8"文件发送失败！", u8"关闭");
  306.         }
  307.     }
  308. }

  310. void Widget::receiveStatus(YmodemFileReceive::Status status)
  311. {
  312.     switch(status)
  313.     {
  314.         case YmodemFileReceive::StatusEstablish:
  315.         {
  316.             break;
  317.         }

  319.         case YmodemFileReceive::StatusTransmit:
  320.         {
  321.             break;
  322.         }

  324.         case YmodemFileReceive::StatusFinish:
  325.         {
  326.             receiveButtonStatus = false;

  328.             ui->comButton->setEnabled(true);

  330.             ui->transmitBrowse->setEnabled(true);

  332.             if(ui->transmitPath->text().isEmpty() != true)
  333.             {
  334.                 ui->transmitButton->setEnabled(true);
  335.             }

  337.             ui->receiveBrowse->setEnabled(true);
  338.             ui->receiveButton->setText(u8"接收");

  340.             QMessageBox::warning(this, u8"成功", u8"文件接收成功！", u8"关闭");

  342.             break;
  343.         }

  345.         case YmodemFileReceive::StatusAbort:
  346.         {
  347.             receiveButtonStatus = false;

  349.             ui->comButton->setEnabled(true);

  351.             ui->transmitBrowse->setEnabled(true);

  353.             if(ui->transmitPath->text().isEmpty() != true)
  354.             {
  355.                 ui->transmitButton->setEnabled(true);
  356.             }

  358.             ui->receiveBrowse->setEnabled(true);
  359.             ui->receiveButton->setText(u8"接收");

  361.             QMessageBox::warning(this, u8"失败", u8"文件接收失败！", u8"关闭");

  363.             break;
  364.         }

  366.         case YmodemFileReceive::StatusTimeout:
  367.         {
  368.             receiveButtonStatus = false;

  370.             ui->comButton->setEnabled(true);

  372.             ui->transmitBrowse->setEnabled(true);

  374.             if(ui->transmitPath->text().isEmpty() != true)
  375.             {
  376.                 ui->transmitButton->setEnabled(true);
  377.             }

  379.             ui->receiveBrowse->setEnabled(true);
  380.             ui->receiveButton->setText(u8"接收");

  382.             QMessageBox::warning(this, u8"失败", u8"文件接收失败！", u8"关闭");

  384.             break;
  385.         }

  387.         default:
  388.         {
  389.             receiveButtonStatus = false;

  391.             ui->comButton->setEnabled(true);

  393.             ui->transmitBrowse->setEnabled(true);

  395.             if(ui->transmitPath->text().isEmpty() != true)
  396.             {
  397.                 ui->transmitButton->setEnabled(true);
  398.             }

  400.             ui->receiveBrowse->setEnabled(true);
  401.             ui->receiveButton->setText(u8"接收");

  403.             QMessageBox::warning(this, u8"失败", u8"文件接收失败！", u8"关闭");
  404.         }
  405.     }
  406. }
复制代码






赞 评论
XinLiYF 回答时间：2018-3-6 22:32:40
      main.cpp文件
  1. #include "widget.h"
  2. #include <QApplication>

  4. int main(int argc, char *argv[])
  5. {
  6.     QApplication a(argc, argv);
  7.     Widget w;
  8.     w.show();

  10.     return a.exec();
  11. }
复制代码

      SerialPortYmodem.pro文件
  1. #-------------------------------------------------
  2. #
  3. # Project created by QtCreator 2018-01-20T23:00:46
  4. #
  5. #-------------------------------------------------

  7. QT       += core gui
  8. QT       += serialport

  10. greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

  12. TARGET = SerialPortYmodem
  13. TEMPLATE = app

  15. # The following define makes your compiler emit warnings if you use
  16. # any feature of Qt which as been marked as deprecated (the exact warnings
  17. # depend on your compiler). Please consult the documentation of the
  18. # deprecated API in order to know how to port your code away from it.
  19. DEFINES += QT_DEPRECATED_WARNINGS

  21. # You can also make your code fail to compile if you use deprecated APIs.
  22. # In order to do so, uncomment the following line.
  23. # You can also select to disable deprecated APIs only up to a certain version of Qt.
  24. #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0


  27. SOURCES += main.cpp\
  28.         widget.cpp \
  29.     YmodemFileReceive.cpp \
  30.     Ymodem.cpp \
  31.     YmodemFileTransmit.cpp

  33. HEADERS  += widget.h \
  34.     Ymodem.h \
  35.     YmodemFileReceive.h \
  36.     YmodemFileTransmit.h

  38. FORMS    += widget.ui

  40. RC_ICONS = SerialPortYmodem.ico
复制代码

      SerialPortYmodem.ico文件

3，运行效果




赞 评论
XinLiYF 回答时间：2018-3-6 22:33:09
可以用来做用户程序升级的上位机软件。GitHub仓库有工程，还有资料。
赞 评论
anobodykey 回答时间：2018-3-7 09:21:37
感谢楼主分享
赞 评论
shuihehe 回答时间：2018-8-13 15:37:45
网络在线升级的技术资料呢？
赞 评论
any012 回答时间：2018-12-19 14:03:21
请教，单片机端如何处理呢？
赞 评论
XinLiYF 回答时间：2018-12-22 17:06:17
any012 发表于 2018-12-19 14:03
请教，单片机端如何处理呢？

可以移植到单片机上，文件的接收和发送都支持。
赞 评论
Kevin_G 回答时间：2018-12-26 09:46:05
收藏
赞 评论
huangchao09 回答时间：2019-3-24 20:37:59
多谢楼主共享
赞 评论

所属标签

关于
意法半导体
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
STM32N6 AI生态系统
STM32MCU,MPU高性能GUI
ST ACEPACK电源模块
意法半导体生物传感器
STM32Cube扩展软件包
关注我们
st-img 微信公众号
st-img 手机版