ST官方代码——YModem协议部分代码分析

zirong0804 · 发表于 2019-1-13 00:08:34

本帖最后由 zirong0804 于 2019-1-13 10:30 编辑

感谢前人的分享资料，网上关于STM32 bootloader资料很多，传输协议可以自定义或使用标准YModem
但细细品味ST官方IAP中YModem协议文章没有，在此跑了一遍ST官方IAP代码，分享给大家！关于实验结论，欢迎交流！

1-实验结论：
对比标准Ymodem协议，ST官方IAP代码中YModem协议少了以下部分：（ST官方代码中YModem协议怎么会少内容呢？）

发送端(secureCRT 8.5) 接收端(开发板)
EOT---->
NAK----<

2-YModem
YModem协议是由XModem协议演变而来的，每包数据可以达到1024字节，是一个非常高效的文件传输协议。参考资料如下
https://www.amobbs.com/thread-5559677-1-1.html
https://baike.baidu.com/item/Ymodem?fr=aladdin
https://blog.csdn.net/qingzhuyuxian/article/details/80769163

3-ST官方IAP工程代码 (请见附件)

4-修改后的STM32f103ZET6工程代码，对ymodem.c添加注释和调试代码（请见附件）
串口1用于与secureCRT 8.5通信，串口2用于打印调试代码

5-ymodem.c文件代码分析，请见工程中
Ymodem_Receive(), Receive_Packet()

7-分享不错的STM32 IAP文章
http://www.openedv.com/thread-78079-1-1.html

6-实验结果：

主楼一区401 · 发表于 2019-1-13 01:20:05

这个资料可以，先拜读下

weiwei4 · 发表于 2019-1-13 08:04:11

谢谢分享，学习了，还没用过

zirong0804 · 发表于 2019-1-13 09:35:39

对比标准Ymodem协议，ST官方代码中YModem协议怎么会少内容呢？

li99932li · 发表于 2019-1-13 09:48:54

谢谢分享，学习了，记号

lrzxc · 发表于 2019-1-13 11:15:40

记号一下，礼拜一试试，谢谢分享

ztrx · 发表于 2019-1-13 11:21:04

调试工具是哪个

armstrong · 发表于 2019-1-13 12:42:03

STcubeMX里的ymodem问题不少的，除了楼主说出的EOT只应答ACK的错误，还有个错误就是数据块编号从FF到00时（也就是传输数据块超过255时），代码会把00块当作新的文件名信息块。

Recoochang · 发表于 2019-1-13 12:42:43

不错，感谢分享

armstrong · 发表于 2019-1-13 12:46:46

还有更多错误

armstrong · 发表于 2019-1-13 12:55:37

还有错误

armstrong · 发表于 2019-1-13 12:56:51

还有更多错误，呵呵

armstrong · 发表于 2019-1-13 13:04:24

看了ST的ymodem代码，会让人担心ST工程师队伍里有混饭吃的。

mdcao · 发表于 2019-1-13 17:10:21

MARK，用到时在看

gsq19920418 · 发表于 2019-1-13 17:54:22

有些东西还得自己写，靠谱些！

zirong0804 · 发表于 2019-1-13 17:56:09

ztrx 发表于 2019-1-13 11:21
调试工具是哪个

secureCRT 8.5

zirong0804 · 发表于 2019-1-13 18:18:22

armstrong 发表于 2019-1-13 12:42
STcubeMX里的ymodem问题不少的，除了楼主说出的EOT只应答ACK的错误，还有个错误就是数据块编号从FF到00时（ ...

谢谢提醒，从我目前的ymodem.c文件来看，这种情况不会发生，理由如下
1-packets_received 被定义为 int32_t
2- 假设packets_received 为256，if (packets_received == 0) 这个条件不满足，所以它还会被当做 Data packet 处理

zirong0804 · 发表于 2019-1-13 18:22:52

armstrong 发表于 2019-1-13 12:46
还有更多错误

谢谢分享，目前代码中使用的ymodem.c 没有这问题

zirong0804 · 发表于 2019-1-13 18:27:13

armstrong 发表于 2019-1-13 12:55
还有错误

的确，目前代码中定义，一般够用
#define FILE_NAME_LENGTH (256)
#define FILE_SIZE_LENGTH (16)

armstrong · 发表于 2019-1-13 18:34:09

zirong0804 发表于 2019-1-13 18:27
的确，目前代码中定义，一般够用
#define FILE_NAME_LENGTH (256)
#define FILE_SIZE_LENGTH ...

楼主你用的ymodem是哪里来的？我的跟你不一样。我是这些目录里的：

armstrong · 发表于 2019-1-13 18:35:31

本帖最后由 armstrong 于 2019-1-13 18:36 编辑

zirong0804 发表于 2019-1-13 18:18
谢谢提醒，从我目前的ymodem.c文件来看，这种情况不会发生，理由如下
1-packets_received 被定义为 int32 ...

问题不是本地定义的数据类型，是ymodem协议只有一个字节用于编号，这就注定0xff之后就会变成0x00。
如果代码本地无视这个规则，自增到256了，那就再也不会跟接收的数据包编号对应上了。

armstrong · 发表于 2019-1-13 18:40:10

随便传一个STM32CubeMX\Repository\STM32Cube_FW_F1_V1.7.0\Projects\STM3210C_EVAL\Applications\IAP\IAP_Main\Src\ymodem.c
其它F4，F7的都一样错：

/**
******************************************************************************
* @file IAP_Main/Src/ymodem.c
* @author MCD Application Team
* @version V1.6.0
* @date 12-May-2017
* @brief This file provides all the software functions related to the ymodem
* protocol.
******************************************************************************
* @attention
*
* <h2><center>© Copyright ?2016 STMicroelectronics International N.V.
* All rights reserved.</center></h2>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted, provided that the following conditions are met:
*
* 1. Redistribution of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. Neither the name of STMicroelectronics nor the names of other
* contributors to this software may be used to endorse or promote products
* derived from this software without specific written permission.
* 4. This software, including modifications and/or derivative works of this
* software, must execute solely and exclusively on microcontroller or
* microprocessor devices manufactured by or for STMicroelectronics.
* 5. Redistribution and use of this software other than as permitted under
* this license is void and will automatically terminate your rights under
* this license.
*
* THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY
* RIGHTS ARE DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT
* SHALL STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************
*/
/** @addtogroup STM32F1xx_IAP
* @{
*/
/* Includes ------------------------------------------------------------------*/
#include "flash_if.h"
#include "common.h"
#include "ymodem.h"
#include "string.h"
#include "main.h"
#include "menu.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define CRC16_F /* activate the CRC16 integrity */
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* @note ATTENTION - please keep this variable 32bit alligned */
uint8_t aPacketData[PACKET_1K_SIZE + PACKET_DATA_INDEX + PACKET_TRAILER_SIZE];
/* Private function prototypes -----------------------------------------------*/
static void PrepareIntialPacket(uint8_t *p_data, const uint8_t *p_file_name, uint32_t length);
static void PreparePacket(uint8_t *p_source, uint8_t *p_packet, uint8_t pkt_nr, uint32_t size_blk);
static HAL_StatusTypeDef ReceivePacket(uint8_t *p_data, uint32_t *p_length, uint32_t timeout);
uint16_t UpdateCRC16(uint16_t crc_in, uint8_t byte);
uint16_t Cal_CRC16(const uint8_t* p_data, uint32_t size);
uint8_t CalcChecksum(const uint8_t *p_data, uint32_t size);
/* Private functions ---------------------------------------------------------*/
/**
* @brief Receive a packet from sender
* @param data
* @param length
* 0: end of transmission
* 2: abort by sender
* >0: packet length
* @param timeout
* @retval HAL_OK: normally return
* HAL_BUSY: abort by user
*/
static HAL_StatusTypeDef ReceivePacket(uint8_t *p_data, uint32_t *p_length, uint32_t timeout)
{
uint32_t crc;
uint32_t packet_size = 0;
HAL_StatusTypeDef status;
uint8_t char1;
*p_length = 0;
status = HAL_UART_Receive(&UartHandle, &char1, 1, timeout);
if (status == HAL_OK)
{
switch (char1)
{
case SOH:
packet_size = PACKET_SIZE;
break;
case STX:
packet_size = PACKET_1K_SIZE;
break;
case EOT:
break;
case CA:
if ((HAL_UART_Receive(&UartHandle, &char1, 1, timeout) == HAL_OK) && (char1 == CA))
{
packet_size = 2;
}
else
{
status = HAL_ERROR;
}
break;
case ABORT1:
case ABORT2:
status = HAL_BUSY;
break;
default:
status = HAL_ERROR;
break;
}
*p_data = char1;
if (packet_size >= PACKET_SIZE )
{
status = HAL_UART_Receive(&UartHandle, &p_data[PACKET_NUMBER_INDEX], packet_size + PACKET_OVERHEAD_SIZE, timeout);
/* Simple packet sanity check */
if (status == HAL_OK )
{
if (p_data[PACKET_NUMBER_INDEX] != ((p_data[PACKET_CNUMBER_INDEX]) ^ NEGATIVE_BYTE))
{
packet_size = 0;
status = HAL_ERROR;
}
else
{
/* Check packet CRC */
crc = p_data[ packet_size + PACKET_DATA_INDEX ] << 8;
crc += p_data[ packet_size + PACKET_DATA_INDEX + 1 ];
if (Cal_CRC16(&p_data[PACKET_DATA_INDEX], packet_size) != crc )
{
packet_size = 0;
status = HAL_ERROR;
}
}
}
else
{
packet_size = 0;
}
}
}
*p_length = packet_size;
return status;
}
/**
* @brief Prepare the first block
* @param p_data: output buffer
* @param p_file_name: name of the file to be sent
* @param length: length of the file to be sent in bytes
* @retval None
*/
static void PrepareIntialPacket(uint8_t *p_data, const uint8_t *p_file_name, uint32_t length)
{
uint32_t i, j = 0;
uint8_t astring[10];
/* first 3 bytes are constant */
p_data[PACKET_START_INDEX] = SOH;
p_data[PACKET_NUMBER_INDEX] = 0x00;
p_data[PACKET_CNUMBER_INDEX] = 0xff;
/* Filename written */
for (i = 0; (p_file_name[i] != '\0') && (i < FILE_NAME_LENGTH); i++)
{
p_data[i + PACKET_DATA_INDEX] = p_file_name[i];
}
p_data[i + PACKET_DATA_INDEX] = 0x00;
/* file size written */
Int2Str (astring, length);
i = i + PACKET_DATA_INDEX + 1;
while (astring[j] != '\0')
{
p_data[i++] = astring[j++];
}
/* padding with zeros */
for (j = i; j < PACKET_SIZE + PACKET_DATA_INDEX; j++)
{
p_data[j] = 0;
}
}
/**
* @brief Prepare the data packet
* @param p_source: pointer to the data to be sent
* @param p_packet: pointer to the output buffer
* @param pkt_nr: number of the packet
* @param size_blk: length of the block to be sent in bytes
* @retval None
*/
static void PreparePacket(uint8_t *p_source, uint8_t *p_packet, uint8_t pkt_nr, uint32_t size_blk)
{
uint8_t *p_record;
uint32_t i, size, packet_size;
/* Make first three packet */
packet_size = size_blk >= PACKET_1K_SIZE ? PACKET_1K_SIZE : PACKET_SIZE;
size = size_blk < packet_size ? size_blk : packet_size;
if (packet_size == PACKET_1K_SIZE)
{
p_packet[PACKET_START_INDEX] = STX;
}
else
{
p_packet[PACKET_START_INDEX] = SOH;
}
p_packet[PACKET_NUMBER_INDEX] = pkt_nr;
p_packet[PACKET_CNUMBER_INDEX] = (~pkt_nr);
p_record = p_source;
/* Filename packet has valid data */
for (i = PACKET_DATA_INDEX; i < size + PACKET_DATA_INDEX;i++)
{
p_packet[i] = *p_record++;
}
if ( size <= packet_size)
{
for (i = size + PACKET_DATA_INDEX; i < packet_size + PACKET_DATA_INDEX; i++)
{
p_packet[i] = 0x1A; /* EOF (0x1A) or 0x00 */
}
}
}
/**
* @brief Update CRC16 for input byte
* @param crc_in input value
* @param input byte
* @retval None
*/
uint16_t UpdateCRC16(uint16_t crc_in, uint8_t byte)
{
uint32_t crc = crc_in;
uint32_t in = byte | 0x100;
do
{
crc <<= 1;
in <<= 1;
if(in & 0x100)
++crc;
if(crc & 0x10000)
crc ^= 0x1021;
}
while(!(in & 0x10000));
return crc & 0xffffu;
}
/**
* @brief Cal CRC16 for YModem Packet
* @param data
* @param length
* @retval None
*/
uint16_t Cal_CRC16(const uint8_t* p_data, uint32_t size)
{
uint32_t crc = 0;
const uint8_t* dataEnd = p_data+size;
while(p_data < dataEnd)
crc = UpdateCRC16(crc, *p_data++);
crc = UpdateCRC16(crc, 0);
crc = UpdateCRC16(crc, 0);
return crc&0xffffu;
}
/**
* @brief Calculate Check sum for YModem Packet
* @param p_data Pointer to input data
* @param size length of input data
* @retval uint8_t checksum value
*/
uint8_t CalcChecksum(const uint8_t *p_data, uint32_t size)
{
uint32_t sum = 0;
const uint8_t *p_data_end = p_data + size;
while (p_data < p_data_end )
{
sum += *p_data++;
}
return (sum & 0xffu);
}
/* Public functions ---------------------------------------------------------*/
/**
* @brief Receive a file using the ymodem protocol with CRC16.
* @param p_size The size of the file.
* @retval COM_StatusTypeDef result of reception/programming
*/
COM_StatusTypeDef Ymodem_Receive ( uint32_t *p_size )
{
uint32_t i, packet_length, session_done = 0, file_done, errors = 0, session_begin = 0;
uint32_t flashdestination, ramsource, filesize;
uint8_t *file_ptr;
uint8_t file_size[FILE_SIZE_LENGTH], tmp, packets_received;
COM_StatusTypeDef result = COM_OK;
/* Initialize flashdestination variable */
flashdestination = APPLICATION_ADDRESS;
while ((session_done == 0) && (result == COM_OK))
{
packets_received = 0;
file_done = 0;
while ((file_done == 0) && (result == COM_OK))
{
switch (ReceivePacket(aPacketData, &packet_length, DOWNLOAD_TIMEOUT))
{
case HAL_OK:
errors = 0;
switch (packet_length)
{
case 2:
/* Abort by sender */
Serial_PutByte(ACK);
result = COM_ABORT;
break;
case 0:
/* End of transmission */
Serial_PutByte(ACK);
file_done = 1;
break;
default:
/* Normal packet */
if (aPacketData[PACKET_NUMBER_INDEX] != packets_received)
{
Serial_PutByte(NAK);
}
else
{
if (packets_received == 0)
{
/* File name packet */
if (aPacketData[PACKET_DATA_INDEX] != 0)
{
/* File name extraction */
i = 0;
file_ptr = aPacketData + PACKET_DATA_INDEX;
while ( (*file_ptr != 0) && (i < FILE_NAME_LENGTH))
{
aFileName[i++] = *file_ptr++;
}
/* File size extraction */
aFileName[i++] = '\0';
i = 0;
file_ptr ++;
while ( (*file_ptr != ' ') && (i < FILE_SIZE_LENGTH))
{
file_size[i++] = *file_ptr++;
}
file_size[i++] = '\0';
Str2Int(file_size, &filesize);
/* Test the size of the image to be sent */
/* Image size is greater than Flash size */
if (*p_size > (USER_FLASH_SIZE + 1))
{
/* End session */
tmp = CA;
HAL_UART_Transmit(&UartHandle, &tmp, 1, NAK_TIMEOUT);
HAL_UART_Transmit(&UartHandle, &tmp, 1, NAK_TIMEOUT);
result = COM_LIMIT;
}
/* erase user application area */
FLASH_If_Erase(APPLICATION_ADDRESS);
*p_size = filesize;
Serial_PutByte(ACK);
Serial_PutByte(CRC16);
}
/* File header packet is empty, end session */
else
{
Serial_PutByte(ACK);
file_done = 1;
session_done = 1;
break;
}
}
else /* Data packet */
{
ramsource = (uint32_t) & aPacketData[PACKET_DATA_INDEX];
/* Write received data in Flash */
if (FLASH_If_Write(flashdestination, (uint32_t*) ramsource, packet_length/4) == FLASHIF_OK)
{
flashdestination += packet_length;
Serial_PutByte(ACK);
}
else /* An error occurred while writing to Flash memory */
{
/* End session */
Serial_PutByte(CA);
Serial_PutByte(CA);
result = COM_DATA;
}
}
packets_received ++;
session_begin = 1;
}
break;
}
break;
case HAL_BUSY: /* Abort actually */
Serial_PutByte(CA);
Serial_PutByte(CA);
result = COM_ABORT;
break;
default:
if (session_begin > 0)
{
errors ++;
}
if (errors > MAX_ERRORS)
{
/* Abort communication */
Serial_PutByte(CA);
Serial_PutByte(CA);
}
else
{
Serial_PutByte(CRC16); /* Ask for a packet */
}
break;
}
}
}
return result;
}
/**
* @brief Transmit a file using the ymodem protocol
* @param p_buf: Address of the first byte
* @param p_file_name: Name of the file sent
* @param file_size: Size of the transmission
* @retval COM_StatusTypeDef result of the communication
*/
COM_StatusTypeDef Ymodem_Transmit (uint8_t *p_buf, const uint8_t *p_file_name, uint32_t file_size)
{
uint32_t errors = 0, ack_recpt = 0, size = 0, pkt_size;
uint8_t *p_buf_int;
COM_StatusTypeDef result = COM_OK;
uint32_t blk_number = 1;
uint8_t a_rx_ctrl[2];
uint8_t i;
#ifdef CRC16_F
uint32_t temp_crc;
#else /* CRC16_F */
uint8_t temp_chksum;
#endif /* CRC16_F */
/* Prepare first block - header */
PrepareIntialPacket(aPacketData, p_file_name, file_size);
while (( !ack_recpt ) && ( result == COM_OK ))
{
/* Send Packet */
HAL_UART_Transmit(&UartHandle, &aPacketData[PACKET_START_INDEX], PACKET_SIZE + PACKET_HEADER_SIZE, NAK_TIMEOUT);
/* Send CRC or Check Sum based on CRC16_F */
#ifdef CRC16_F
temp_crc = Cal_CRC16(&aPacketData[PACKET_DATA_INDEX], PACKET_SIZE);
Serial_PutByte(temp_crc >> 8);
Serial_PutByte(temp_crc & 0xFF);
#else /* CRC16_F */
temp_chksum = CalcChecksum (&aPacketData[PACKET_DATA_INDEX], PACKET_SIZE);
Serial_PutByte(temp_chksum);
#endif /* CRC16_F */
/* Wait for Ack and 'C' */
if (HAL_UART_Receive(&UartHandle, &a_rx_ctrl[0], 1, NAK_TIMEOUT) == HAL_OK)
{
if (a_rx_ctrl[0] == ACK)
{
ack_recpt = 1;
}
else if (a_rx_ctrl[0] == CA)
{
if ((HAL_UART_Receive(&UartHandle, &a_rx_ctrl[0], 1, NAK_TIMEOUT) == HAL_OK) && (a_rx_ctrl[0] == CA))
{
HAL_Delay( 2 );
__HAL_UART_FLUSH_DRREGISTER(&UartHandle);
result = COM_ABORT;
}
}
}
else
{
errors++;
}
if (errors >= MAX_ERRORS)
{
result = COM_ERROR;
}
}
p_buf_int = p_buf;
size = file_size;
/* Here 1024 bytes length is used to send the packets */
while ((size) && (result == COM_OK ))
{
/* Prepare next packet */
PreparePacket(p_buf_int, aPacketData, blk_number, size);
ack_recpt = 0;
a_rx_ctrl[0] = 0;
errors = 0;
/* Resend packet if NAK for few times else end of communication */
while (( !ack_recpt ) && ( result == COM_OK ))
{
/* Send next packet */
if (size >= PACKET_1K_SIZE)
{
pkt_size = PACKET_1K_SIZE;
}
else
{
pkt_size = PACKET_SIZE;
}
HAL_UART_Transmit(&UartHandle, &aPacketData[PACKET_START_INDEX], pkt_size + PACKET_HEADER_SIZE, NAK_TIMEOUT);
/* Send CRC or Check Sum based on CRC16_F */
#ifdef CRC16_F
temp_crc = Cal_CRC16(&aPacketData[PACKET_DATA_INDEX], pkt_size);
Serial_PutByte(temp_crc >> 8);
Serial_PutByte(temp_crc & 0xFF);
#else /* CRC16_F */
temp_chksum = CalcChecksum (&aPacketData[PACKET_DATA_INDEX], pkt_size);
Serial_PutByte(temp_chksum);
#endif /* CRC16_F */
/* Wait for Ack */
if ((HAL_UART_Receive(&UartHandle, &a_rx_ctrl[0], 1, NAK_TIMEOUT) == HAL_OK) && (a_rx_ctrl[0] == ACK))
{
ack_recpt = 1;
if (size > pkt_size)
{
p_buf_int += pkt_size;
size -= pkt_size;
if (blk_number == (USER_FLASH_SIZE / PACKET_1K_SIZE))
{
result = COM_LIMIT; /* boundary error */
}
else
{
blk_number++;
}
}
else
{
p_buf_int += pkt_size;
size = 0;
}
}
else
{
errors++;
}
/* Resend packet if NAK for a count of 10 else end of communication */
if (errors >= MAX_ERRORS)
{
result = COM_ERROR;
}
}
}
/* Sending End Of Transmission char */
ack_recpt = 0;
a_rx_ctrl[0] = 0x00;
errors = 0;
while (( !ack_recpt ) && ( result == COM_OK ))
{
Serial_PutByte(EOT);
/* Wait for Ack */
if (HAL_UART_Receive(&UartHandle, &a_rx_ctrl[0], 1, NAK_TIMEOUT) == HAL_OK)
{
if (a_rx_ctrl[0] == ACK)
{
ack_recpt = 1;
}
else if (a_rx_ctrl[0] == CA)
{
if ((HAL_UART_Receive(&UartHandle, &a_rx_ctrl[0], 1, NAK_TIMEOUT) == HAL_OK) && (a_rx_ctrl[0] == CA))
{
HAL_Delay( 2 );
__HAL_UART_FLUSH_DRREGISTER(&UartHandle);
result = COM_ABORT;
}
}
}
else
{
errors++;
}
if (errors >= MAX_ERRORS)
{
result = COM_ERROR;
}
}
/* Empty packet sent - some terminal emulators need this to close session */
if ( result == COM_OK )
{
/* Preparing an empty packet */
aPacketData[PACKET_START_INDEX] = SOH;
aPacketData[PACKET_NUMBER_INDEX] = 0;
aPacketData[PACKET_CNUMBER_INDEX] = 0xFF;
for (i = PACKET_DATA_INDEX; i < (PACKET_SIZE + PACKET_DATA_INDEX); i++)
{
aPacketData [i] = 0x00;
}
/* Send Packet */
HAL_UART_Transmit(&UartHandle, &aPacketData[PACKET_START_INDEX], PACKET_SIZE + PACKET_HEADER_SIZE, NAK_TIMEOUT);
/* Send CRC or Check Sum based on CRC16_F */
#ifdef CRC16_F
temp_crc = Cal_CRC16(&aPacketData[PACKET_DATA_INDEX], PACKET_SIZE);
Serial_PutByte(temp_crc >> 8);
Serial_PutByte(temp_crc & 0xFF);
#else /* CRC16_F */
temp_chksum = CalcChecksum (&aPacketData[PACKET_DATA_INDEX], PACKET_SIZE);
Serial_PutByte(temp_chksum);
#endif /* CRC16_F */
/* Wait for Ack and 'C' */
if (HAL_UART_Receive(&UartHandle, &a_rx_ctrl[0], 1, NAK_TIMEOUT) == HAL_OK)
{
if (a_rx_ctrl[0] == CA)
{
HAL_Delay( 2 );
__HAL_UART_FLUSH_DRREGISTER(&UartHandle);
result = COM_ABORT;
}
}
}
return result; /* file transmitted successfully */
}
/**
* @}
*/
/*******************(C)COPYRIGHT 2016 STMicroelectronics *****END OF FILE****/

复制代码

mypc16888 · 发表于 2019-1-13 18:44:02

学习了，感谢分享

armstrong · 发表于 2019-1-13 18:48:41

经过每个文件查看过去，官方STM32CubeMX目录里的ymodem.c（注意我楼上的目录截图）都是错的。楼主使用的文件是经网友修改过的，所以问题并不一致。

zirong0804 · 发表于 2019-1-13 18:49:49

本帖最后由 zirong0804 于 2019-1-13 18:51 编辑

armstrong 发表于 2019-1-13 18:34
楼主你用的ymodem是哪里来的？我的跟你不一样。我是这些目录里的：

你是新版本，我这是老版本了
STM32F0xx_AN4065_FW_V1.0.0\Project\STM32F0xx_IAP\src

  ******************************************************************************
  * @file STM32F0xx_IAP/src/ymodem.c
  * @author  MCD Application Team
  * @version V1.0.0
  * @date 29-May-2012
  * @brief Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>© COPYRIGHT 2012 STMicroelectronics</center></h2>

zirong0804 · 发表于 2019-1-13 18:53:06

本帖最后由 zirong0804 于 2019-1-13 18:55 编辑

armstrong 发表于 2019-1-13 18:48
经过每个文件查看过去，官方STM32CubeMX目录里的ymodem.c（注意我楼上的目录截图）都是错的。楼主使用的文 ...

是的，很高兴分享，讨论，学习

方便的话，提供下你文件的下载连接

armstrong · 发表于 2019-1-13 18:54:27

zirong0804 发表于 2019-1-13 18:49
你是新版本，我这是老版本了
STM32F0xx_AN4065_FW_V1.0.0\Project\STM32F0xx_IAP\src

word天！这些ST工程师居然把原先还算正确代码改成错误百出的新代码了！
你的旧代码是2012年的，而新的文件是2017年的，全在STM32CubeMX目录里！

zirong0804 · 发表于 2019-1-13 18:58:33

armstrong 发表于 2019-1-13 18:54
word天！这些ST工程师居然把原先还算正确代码改成错误百出的新代码了！
你的旧代码是2012年的，而新的文 ...

是的，还有个问题：使用secureCRT，怎么让它选择STX 1024字节传输，目前都是使用 SOH 128字节传输

armstrong · 发表于 2019-1-13 19:00:55

zirong0804 发表于 2019-1-13 18:58
是的，还有个问题：使用secureCRT，怎么让它选择STX 1024字节传输，目前都是使用 SOH 128字节传输 ...

这个要在secureCRT选项中设定

小大琦_守护天使 · 发表于 2019-1-13 20:54:15

MARK一下

kinsno · 发表于 2019-1-13 23:18:43

armstrong 发表于 2019-1-13 19:00
这个要在secureCRT选项中设定

我去，YMODE都要去研究啊，我放弃了这个玩意，直接私有协议飞起。。。

tear604922959 · 发表于 2019-1-14 15:25:23

谢谢分享，学习了，还没用过

TKZXJ · 发表于 2019-1-14 16:00:26

谢谢分享

armstrong · 发表于 2019-1-14 17:40:31

kinsno 发表于 2019-1-13 23:18
我去，YMODE都要去研究啊，我放弃了这个玩意，直接私有协议飞起。。。

...

主要是懒得写PC工具。私有协议速度应该能更快。
目前我用SecureCRT，2Mbps的波特率时，传输率才100kB/s；逻辑分析仪看起来，传输带宽利用率只有50%，太低了！

zirong0804 · 发表于 2019-1-15 21:05:07

本帖最后由 zirong0804 于 2019-1-15 21:06 编辑

修改代码，符合标准YModem协议，具体如下

1-接收端在第一次收到EOT时，发送NAK。那么发送端会再一次发送EOT，此时接收端发送ACK应答

发送端                                  接收端
                                       C---<
SOH-->
                                             ACK---<
                                                C---<
SOH-->
                                          ACK---<
SOH-->
                                          ACK---<
...
SOH-->
                                          ACK---<
SOH-->
                                          ACK---<
EOT-->
                                          NAK---<
EOT-->
                                          ACK---<
         (调试代码为ACK-end<)
                                                C---<
SOH-->
                                          ACK---<

      （调试代码为ACK-empty<）

1a2b3c · 发表于 2019-4-29 10:43:53

正好遇到了新问题要请教一下楼主及各位

有没有谁使用超级终端的 winsock 方式传输 Ymodem 的呢？
目前还没有找到有人这么做，资料也没有多少研究的人，好像看了他的传输内容和串口的不一样啊

zirong0804 · 发表于 2019-5-5 08:37:16

1a2b3c 发表于 2019-4-29 10:43
正好遇到了新问题要请教一下楼主及各位

有没有谁使用超级终端的 winsock 方式传输 Ymodem 的呢？

不好意思，没有学习过

lanlibo · 发表于 2019-5-5 09:22:44

感谢楼主分享

Dragontan · 发表于 2020-3-16 07:51:59

感谢楼主的分享

长毛小兔 · 发表于 2020-9-3 14:33:30

正在学习这一部分，及时雨

abcdzhy · 发表于 2020-9-3 15:01:45

多谢楼主分享

lwjok008 · 发表于 2020-10-18 19:27:45

多谢分享，正在学习。

BS_good200xy · 发表于 2021-1-5 08:19:22

多谢分享！最近也在研究YMODEM，用C#写了YMODEM文件发送，文件接收还没写好。

abcdzhy · 发表于 2021-1-5 13:31:29

YMODEM感觉升级的话用的很多啊

vergoo · 发表于 2021-10-8 09:03:04

感谢分享

krguang · 发表于 2021-10-9 09:41:52

armstrong 发表于 2019-1-14 17:40
主要是懒得写PC工具。私有协议速度应该能更快。
目前我用SecureCRT，2Mbps的波特率时，传输率才100kB/s； ...

是不是传输太快,flash写入速度跟不上,所以是发送端在等待接收端

1324324 · 发表于 2021-12-1 13:39:16

程序在烧写大一点的bin文件时，会卡死

qwe2231695 · 发表于 2021-12-1 22:42:10

XModem 方便很多

fyq2000wx · 发表于 2021-12-23 11:14:41

多谢分享，正在学习。

csq463276932 · 发表于 2021-12-27 10:38:39

zirong0804 发表于 2019-1-13 18:27
的确，目前代码中定义，一般够用
#define FILE_NAME_LENGTH (256)
#define FILE_SIZE_LENGTH ...

请教下楼主为何文件名长度定义256字节，文件大小定义16字节，看协议这两个加起来最长就128字节吧。
#define FILE_NAME_LENGTH (256)
#define FILE_SIZE_LENGTH (16)

ST官方代码——YModem协议部分代码分析

本帖子中包含更多资源

阿莫论坛20周年了！感谢大家的支持与爱护！！

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源