You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
557 lines
12 KiB
557 lines
12 KiB
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "ymodem.h"
|
|
#include "tick.h"
|
|
#include "serial.h"
|
|
|
|
/* Common routines */
|
|
#define IS_AF(c) ((c >= 'A') && (c <= 'F'))
|
|
#define IS_af(c) ((c >= 'a') && (c <= 'f'))
|
|
#define IS_09(c) ((c >= '0') && (c <= '9'))
|
|
#define ISVALIDHEX(c) IS_AF(c) || IS_af(c) || IS_09(c)
|
|
#define ISVALIDDEC(c) IS_09(c)
|
|
#define CONVERTDEC(c) (c - '0')
|
|
#define CONVERTHEX_alpha(c) (IS_AF(c) ? (c - 'A'+10) : (c - 'a'+10))
|
|
#define CONVERTHEX(c) (IS_09(c) ? (c - '0') : CONVERTHEX_alpha(c))
|
|
|
|
/**
|
|
* @brief Receive byte from sender
|
|
* @param c: Character
|
|
* @param timeout: Timeout
|
|
* @retval 0: Byte received
|
|
* -1: Timeout
|
|
*/
|
|
static int get_byte(struct serial *uart, uint8_t *c, uint32_t timeout)
|
|
{
|
|
uint64_t end = millis() + timeout;
|
|
while (millis() < end) {
|
|
if (serial_recv_buffered(uart, c, 1) == 1) {
|
|
return 0;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* @brief Send a byte
|
|
* @param c: Character
|
|
* @retval 0: Byte sent
|
|
*/
|
|
static int put_byte (struct serial *uart, uint8_t c)
|
|
{
|
|
int n;
|
|
|
|
do {
|
|
n = serial_send_buffered(uart, &c, 1);
|
|
} while (n != 1);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Receive a packet from sender
|
|
* @param data
|
|
* @param length
|
|
* @param timeout
|
|
* 0: end of transmission
|
|
* -1: abort by sender
|
|
* >0: packet length
|
|
* @retval 0: normally return
|
|
* -1: timeout or packet error
|
|
* 1: abort by user
|
|
*/
|
|
static int __recv(struct serial *uart, uint8_t *data, int *length, uint32_t timeout)
|
|
{
|
|
uint16_t i, packet_size;
|
|
uint8_t c;
|
|
*length = 0;
|
|
|
|
if (get_byte(uart, &c, timeout) != 0) {
|
|
return -1;
|
|
}
|
|
|
|
switch (c) {
|
|
case SOH:
|
|
packet_size = PACKET_SIZE;
|
|
break;
|
|
case STX:
|
|
packet_size = PACKET_1K_SIZE;
|
|
break;
|
|
case EOT:
|
|
return 0;
|
|
case CA:
|
|
if ((get_byte(uart, &c, timeout) == 0) && (c == CA)) {
|
|
*length = -1;
|
|
return 0;
|
|
} else {
|
|
return -1;
|
|
}
|
|
case ABORT1:
|
|
case ABORT2:
|
|
return 1;
|
|
default:
|
|
return -1;
|
|
}
|
|
|
|
*data = c;
|
|
for (i = 1; i < (packet_size + PACKET_OVERHEAD); i ++) {
|
|
if (get_byte(uart, data + i, timeout) != 0) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (data[PACKET_SEQNO_INDEX] != ((data[PACKET_SEQNO_COMP_INDEX] ^ 0xff) & 0xff)) {
|
|
return -1;
|
|
}
|
|
*length = packet_size;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* @brief Receive a file using the ymodem protocol.
|
|
*/
|
|
int ymodem_recv(struct serial *uart, void *user,
|
|
int (*on_info)(void *, const char *name, unsigned int size),
|
|
int (*on_data)(void *user, const void *data, unsigned int len))
|
|
{
|
|
char filename[FILE_NAME_LENGTH + 1], file_size[FILE_SIZE_LENGTH + 1];
|
|
uint8_t packet_data[PACKET_1K_SIZE + PACKET_OVERHEAD], *file_ptr;
|
|
int i, packet_length, session_done, file_done, packets_received, errors, session_begin, size = 0;
|
|
|
|
session_done = 0;
|
|
session_begin = 0;
|
|
errors = 0;
|
|
while (session_done == 0) {
|
|
packets_received = 0;
|
|
file_done = 0;
|
|
while (file_done == 0) {
|
|
switch (__recv(uart, packet_data, &packet_length, NAK_TIMEOUT)) {
|
|
case 0:
|
|
errors = 0;
|
|
switch (packet_length) {
|
|
/* Abort by sender */
|
|
case -1:
|
|
put_byte(uart, ACK);
|
|
return 0;
|
|
/* End of transmission */
|
|
case 0:
|
|
put_byte(uart, ACK);
|
|
file_done = 1;
|
|
break;
|
|
/* Normal packet */
|
|
default:
|
|
if ((packet_data[PACKET_SEQNO_INDEX] & 0xff) != (packets_received & 0xff)) {
|
|
put_byte(uart, NAK);
|
|
} else {
|
|
if (packets_received == 0) {
|
|
/* Filename packet */
|
|
if (packet_data[PACKET_HEADER] != 0) {
|
|
/* Filename packet has valid data */
|
|
for (i = 0, file_ptr = packet_data + PACKET_HEADER; (*file_ptr != 0) && (i < FILE_NAME_LENGTH);) {
|
|
filename[i++] = *file_ptr++;
|
|
}
|
|
filename[i++] = '\0';
|
|
for (i = 0, file_ptr++; (*file_ptr != ' ') && (i < FILE_SIZE_LENGTH);) {
|
|
file_size[i++] = *file_ptr++;
|
|
}
|
|
file_size[i++] = '\0';
|
|
size = strtoul(file_size, NULL, 0);
|
|
|
|
/* Test the size of the image to be sent */
|
|
/* Image size is greater than Flash size */
|
|
if (on_info && on_info(user, filename, size)) { /* error */
|
|
/* End session */
|
|
put_byte(uart, CA);
|
|
put_byte(uart, CA);
|
|
return -1;
|
|
}
|
|
put_byte(uart, ACK);
|
|
put_byte(uart, CRC16);
|
|
} else {/* Filename packet is empty, end session */
|
|
put_byte(uart, ACK);
|
|
file_done = 1;
|
|
session_done = 1;
|
|
break;
|
|
}
|
|
} else { /* Data packet */
|
|
/* Write received data in Flash */
|
|
if (on_data) {
|
|
if (on_data(user, packet_data + PACKET_HEADER, packet_length)) { /* An error occurred while writing to Flash memory */
|
|
/* End session */
|
|
put_byte(uart, CA);
|
|
put_byte(uart, CA);
|
|
return -2;
|
|
} else {
|
|
put_byte(uart, ACK);
|
|
}
|
|
} else {
|
|
put_byte(uart, CA);
|
|
put_byte(uart, CA);
|
|
}
|
|
|
|
}
|
|
packets_received++;
|
|
session_begin = 1;
|
|
}
|
|
}
|
|
break;
|
|
case 1:
|
|
put_byte(uart, CA);
|
|
put_byte(uart, CA);
|
|
return -3;
|
|
default:
|
|
if (session_begin > 0) {
|
|
errors ++;
|
|
}
|
|
if (errors > MAX_ERRORS) {
|
|
put_byte(uart, CA);
|
|
put_byte(uart, CA);
|
|
return 0;
|
|
}
|
|
put_byte(uart, CRC16);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return size;
|
|
}
|
|
|
|
/**
|
|
* @brief Prepare the first block
|
|
* @param timeout
|
|
* 0: end of transmission
|
|
* @retval None
|
|
*/
|
|
static void init_packet(uint8_t *data, const uint8_t* fileName, uint32_t *length)
|
|
{
|
|
uint16_t i, j;
|
|
uint8_t file_ptr[10];
|
|
|
|
/* Make first three packet */
|
|
data[0] = SOH;
|
|
data[1] = 0x00;
|
|
data[2] = 0xff;
|
|
|
|
/* Filename packet has valid data */
|
|
for (i = 0; (fileName[i] != '\0') && (i < FILE_NAME_LENGTH);i++) {
|
|
data[i + PACKET_HEADER] = fileName[i];
|
|
}
|
|
|
|
data[i + PACKET_HEADER] = 0x00;
|
|
|
|
snprintf((char *)file_ptr, sizeof file_ptr, "%lu", *length);
|
|
for (j =0, i = i + PACKET_HEADER + 1; file_ptr[j] != '\0' ; ) {
|
|
data[i++] = file_ptr[j++];
|
|
}
|
|
|
|
for (j = i; j < PACKET_SIZE + PACKET_HEADER; j++) {
|
|
data[j] = 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Prepare the data packet
|
|
* @param timeout
|
|
* 0: end of transmission
|
|
* @retval None
|
|
*/
|
|
static void Ymodem_PreparePacket(uint8_t *SourceBuf, uint8_t *data, uint8_t pktNo, uint32_t sizeBlk)
|
|
{
|
|
uint16_t i, size, packetSize;
|
|
uint8_t* file_ptr;
|
|
|
|
/* Make first three packet */
|
|
packetSize = sizeBlk >= PACKET_1K_SIZE ? PACKET_1K_SIZE : PACKET_SIZE;
|
|
size = sizeBlk < packetSize ? sizeBlk :packetSize;
|
|
if (packetSize == PACKET_1K_SIZE)
|
|
{
|
|
data[0] = STX;
|
|
}
|
|
else
|
|
{
|
|
data[0] = SOH;
|
|
}
|
|
data[1] = pktNo;
|
|
data[2] = (~pktNo);
|
|
file_ptr = SourceBuf;
|
|
|
|
/* Filename packet has valid data */
|
|
for (i = PACKET_HEADER; i < size + PACKET_HEADER;i++)
|
|
{
|
|
data[i] = *file_ptr++;
|
|
}
|
|
if ( size <= packetSize)
|
|
{
|
|
for (i = size + PACKET_HEADER; i < packetSize + PACKET_HEADER; i++)
|
|
{
|
|
data[i] = 0x1A; /* EOF (0x1A) or 0x00 */
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Update CRC16 for input byte
|
|
* @param CRC input value
|
|
* @param input byte
|
|
* @retval None
|
|
*/
|
|
static uint16_t crc16(uint16_t crcIn, uint8_t byte)
|
|
{
|
|
uint32_t crc = crcIn;
|
|
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
|
|
*/
|
|
static uint16_t Cal_CRC16(const uint8_t* data, uint32_t size)
|
|
{
|
|
uint32_t crc = 0;
|
|
const uint8_t* dataEnd = data+size;
|
|
|
|
while(data < dataEnd)
|
|
crc = crc16(crc, *data++);
|
|
|
|
crc = crc16(crc, 0);
|
|
crc = crc16(crc, 0);
|
|
|
|
return crc&0xffffu;
|
|
}
|
|
|
|
/**
|
|
* @brief Cal Check sum for YModem Packet
|
|
* @param data
|
|
* @param length
|
|
* @retval None
|
|
*/
|
|
static uint8_t CalChecksum(const uint8_t* data, uint32_t size)
|
|
{
|
|
uint32_t sum = 0;
|
|
const uint8_t* dataEnd = data+size;
|
|
|
|
while(data < dataEnd )
|
|
sum += *data++;
|
|
|
|
return (sum & 0xffu);
|
|
}
|
|
|
|
/**
|
|
* @brief Transmit a data packet using the ymodem protocol
|
|
* @param data
|
|
* @param length
|
|
* @retval None
|
|
*/
|
|
static void send_packet(struct serial *uart, uint8_t *data, uint16_t length)
|
|
{
|
|
uint16_t i;
|
|
i = 0;
|
|
while (i < length) {
|
|
put_byte(uart, data[i]);
|
|
i++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Transmit a file using the ymodem protocol
|
|
* @param buf: Address of the first byte
|
|
* @retval The size of the file
|
|
*/
|
|
uint8_t ymodem_send(struct serial *uart, uint8_t *buf, const uint8_t* sendFileName, uint32_t sizeFile)
|
|
{
|
|
uint8_t packet_data[PACKET_1K_SIZE + PACKET_OVERHEAD];
|
|
uint8_t filename[FILE_NAME_LENGTH];
|
|
uint8_t *buf_ptr, tempCheckSum;
|
|
uint16_t tempCRC;
|
|
uint16_t blkNumber;
|
|
uint8_t receivedC[2], CRC16_F = 0, i;
|
|
uint32_t errors, ackReceived, size = 0, pktSize;
|
|
|
|
errors = 0;
|
|
ackReceived = 0;
|
|
|
|
for (i = 0; i < (FILE_NAME_LENGTH - 1); i++) {
|
|
filename[i] = sendFileName[i];
|
|
}
|
|
CRC16_F = 1;
|
|
|
|
/* Prepare first block */
|
|
init_packet(&packet_data[0], filename, &sizeFile);
|
|
|
|
do {
|
|
/* Send Packet */
|
|
send_packet(uart, packet_data, PACKET_SIZE + PACKET_HEADER);
|
|
|
|
/* Send CRC or Check Sum based on CRC16_F */
|
|
if (CRC16_F) {
|
|
tempCRC = Cal_CRC16(&packet_data[3], PACKET_SIZE);
|
|
put_byte(uart, tempCRC >> 8);
|
|
put_byte(uart, tempCRC & 0xFF);
|
|
} else {
|
|
tempCheckSum = CalChecksum (&packet_data[3], PACKET_SIZE);
|
|
put_byte(uart, tempCheckSum);
|
|
}
|
|
|
|
/* Wait for Ack and 'C' */
|
|
if (get_byte(uart, &receivedC[0], 10000) == 0) {
|
|
if (receivedC[0] == ACK) {
|
|
/* Packet transferred correctly */
|
|
ackReceived = 1;
|
|
}
|
|
} else {
|
|
errors++;
|
|
}
|
|
} while (!ackReceived && (errors < 0x0A));
|
|
|
|
if (errors >= 0x0A) {
|
|
return errors;
|
|
}
|
|
buf_ptr = buf;
|
|
size = sizeFile;
|
|
blkNumber = 0x01;
|
|
/* Here 1024 bytes package is used to send the packets */
|
|
|
|
|
|
/* Resend packet if NAK for a count of 10 else end of communication */
|
|
while (size) {
|
|
/* Prepare next packet */
|
|
Ymodem_PreparePacket(buf_ptr, &packet_data[0], blkNumber, size);
|
|
ackReceived = 0;
|
|
receivedC[0]= 0;
|
|
errors = 0;
|
|
do {
|
|
/* Send next packet */
|
|
if (size >= PACKET_1K_SIZE) {
|
|
pktSize = PACKET_1K_SIZE;
|
|
|
|
} else {
|
|
pktSize = PACKET_SIZE;
|
|
}
|
|
send_packet(uart, packet_data, pktSize + PACKET_HEADER);
|
|
/* Send CRC or Check Sum based on CRC16_F */
|
|
/* Send CRC or Check Sum based on CRC16_F */
|
|
if (CRC16_F) {
|
|
tempCRC = Cal_CRC16(&packet_data[3], pktSize);
|
|
put_byte(uart, tempCRC >> 8);
|
|
put_byte(uart, tempCRC & 0xFF);
|
|
} else {
|
|
tempCheckSum = CalChecksum (&packet_data[3], pktSize);
|
|
put_byte(uart, tempCheckSum);
|
|
}
|
|
|
|
/* Wait for Ack */
|
|
if ((get_byte(uart, &receivedC[0], 100000) == 0) && (receivedC[0] == ACK)) {
|
|
ackReceived = 1;
|
|
if (size > pktSize) {
|
|
buf_ptr += pktSize;
|
|
size -= pktSize;
|
|
if (blkNumber > ((sizeFile / 1024) + 1)) { /* XXX */
|
|
return 0xFF; /* error */
|
|
} else {
|
|
blkNumber++;
|
|
}
|
|
} else {
|
|
buf_ptr += pktSize;
|
|
size = 0;
|
|
}
|
|
} else {
|
|
errors++;
|
|
}
|
|
} while(!ackReceived && (errors < 0x0A));
|
|
/* Resend packet if NAK for a count of 10 else end of communication */
|
|
|
|
if (errors >= 0x0A) {
|
|
return errors;
|
|
}
|
|
|
|
}
|
|
ackReceived = 0;
|
|
receivedC[0] = 0x00;
|
|
errors = 0;
|
|
do {
|
|
put_byte(uart, EOT);
|
|
/* Send (EOT); */
|
|
/* Wait for Ack */
|
|
if ((get_byte(uart, &receivedC[0], 10000) == 0) && receivedC[0] == ACK) {
|
|
ackReceived = 1;
|
|
} else {
|
|
errors++;
|
|
}
|
|
} while (!ackReceived && (errors < 0x0A));
|
|
|
|
if (errors >= 0x0A) {
|
|
return errors;
|
|
}
|
|
|
|
/* Last packet preparation */
|
|
ackReceived = 0;
|
|
receivedC[0] = 0x00;
|
|
errors = 0;
|
|
|
|
packet_data[0] = SOH;
|
|
packet_data[1] = 0;
|
|
packet_data [2] = 0xFF;
|
|
|
|
for (i = PACKET_HEADER; i < (PACKET_SIZE + PACKET_HEADER); i++) {
|
|
packet_data [i] = 0x00;
|
|
}
|
|
|
|
do {
|
|
/* Send Packet */
|
|
send_packet(uart, packet_data, PACKET_SIZE + PACKET_HEADER);
|
|
|
|
/* Send CRC or Check Sum based on CRC16_F */
|
|
tempCRC = Cal_CRC16(&packet_data[3], PACKET_SIZE);
|
|
put_byte(uart, tempCRC >> 8);
|
|
put_byte(uart, tempCRC & 0xFF);
|
|
|
|
/* Wait for Ack and 'C' */
|
|
if (get_byte(uart, &receivedC[0], 10000) == 0)
|
|
{
|
|
if (receivedC[0] == ACK)
|
|
{
|
|
/* Packet transferred correctly */
|
|
ackReceived = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors++;
|
|
}
|
|
} while (!ackReceived && (errors < 0x0A));
|
|
|
|
/* Resend packet if NAK for a count of 10 else end of communication */
|
|
if (errors >= 0x0A) {
|
|
return errors;
|
|
}
|
|
|
|
do {
|
|
put_byte(uart, EOT);
|
|
/* Send (EOT); */
|
|
/* Wait for Ack */
|
|
if ((get_byte(uart, &receivedC[0], 10000) == 0) && receivedC[0] == ACK) {
|
|
ackReceived = 1;
|
|
} else {
|
|
errors++;
|
|
}
|
|
} while (!ackReceived && (errors < 0x0A));
|
|
|
|
if (errors >= 0x0A) {
|
|
return errors;
|
|
}
|
|
return 0; /* file transmitted successfully */
|
|
}
|
|
|
|
|