rooty/LibrePilot
1
0
Fork 0
mirror of https://bitbucket.org/librepilot/librepilot.git synced 2024-11-29 07:24:13 +01:00
Code Issues Releases Activity

git-svn-id: svn://svn.openpilot.org/OpenPilot/trunk@458 ebee16cc-31ac-478f-84a7-5cbb03baadba

Browse Source
This commit is contained in:
zedamota 2010-04-09 22:49:57 +00:00 committed by zedamota
parent b23bac266f
commit 00b1517da4
1 changed files with 420 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

420
ground/src/libs/qymodem/src/qymodem_tx.cpp Executable file
View File

@ -0,0 +1,420 @@
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/**
@file
@brief Implementation of Y-Modem transmit protocol.
*/
#include "qymodem_tx.h"
#include <string.h> // for memcpy and memset
/**
Minimum time in milli-seconds to wait for response from receiver.
*/
const unsigned SendTimeout = 11*1000;
/**
Process response from receiver.
@param c Value received from InChar.
@return One if received an ACKnowledge,
zero if received a Negative AcKnowledge,
or a negative error value.
*/
int QymodemTx::ProcessResponse(int c)
{
if(c<0)
return c;
if(c==CAN)
{
if(CancelCount++)
return ErrorTranferTerminatedByReceiver;
return 0;
}
CancelCount = 0;
if(c==ACK)
return 1;
return 0;
}
/**
Begin the Y-Modem transfer.
@param timeout Time in milliseconds to wait receiver to become ready.
@return Zero if transfer initialisation was successful, or an error code on failure.
*/
int QymodemTx::SendInitialise(unsigned timeout)
{
emit Information("Waiting for Receiver",QymodemTx::InfoSending);
if(timeout<SendTimeout)
timeout = SendTimeout;
while(InChar(-1)>=0) // flush input buffers
{}
CancelCount = 0;
int c;
for(;;)
{
const unsigned timeoutStep = 10;
c = InChar(timeoutStep);
if(c=='G')
{
SendCRC = true;
WaitForBlockACK = false;
break;
}
else if(c=='C')
{
SendCRC = true;
WaitForBlockACK = true;
break;
}
else if(c==NAK)
{
SendCRC = false;
WaitForBlockACK = true;
break;
}
if(c<0 && c!=ErrorTimeout)
return c;
if(timeout<timeoutStep)
return ErrorTimeout;
timeout -= timeoutStep;
}
ModeChar = c;
return 0;
}
/**
Send a single block of data.
A zero sized block terminates the transfer.
@param data The data to transfer.
@param size Size of data.
@return The number of transfered, or an error code on failure.
The number of bytes may be less than \a size.
@pre SendInitialise() must have been successful.
*/
int QymodemTx::SendBlock(const char* data, size_t size)
{
char block[1+2+1024+2]; // buffer to hold data in the block
int retryCount = 10; // number of attempts to send the block
bool waitForBlockACK = WaitForBlockACK;
change_mode:
size_t blockSize = (Use1KBlocks && size>=1024) ? 1024 : 128;
size_t dataSize = size<blockSize ? size : blockSize; // size of data to send in block
if(!dataSize)
{
// all bytes sent, so end transfer by sending a single EOT...
block[0] = EOT;
blockSize = 1;
waitForBlockACK = true;
}
else
{
// make block header...
block[0] = blockSize==1024 ? STX : SOH;
block[1] = BlockNumber&0xffu;
block[2] = (~BlockNumber)&0xffu;
// copy data for block (padding with EOF)...
memcpy(block+3,data,dataSize);
memset(block+3+dataSize,26,blockSize-dataSize);
// append checksum/crc...
if(SendCRC)
{
quint16 crc = CRC16(block+3,blockSize);
blockSize += 3;
block[blockSize++] = (quint8)(crc>>8);
block[blockSize++] = (quint8)crc;
}
else
{
quint8 sum = Checksum(block+3,blockSize);
blockSize += 3;
block[blockSize++] = sum;
}
}
do_retry:
// count attenpts...
if(!retryCount--)
return ErrorBlockRetriesExceded;
char* out = block;
size_t outSize = blockSize;
for(;;)
{
// send some data...
Port.setTimeout(1000);;
int result = (int)Port.write(out,outSize);
if(result<0)
return result; // return error
if(result==0)
return ErrorTimeout;
// adjust for data remaining...
out += result;
outSize -= result;
// end if done...
if(!outSize)
break;
// poll for signal from receiver...
result = ProcessResponse(InChar(10));
if(result==ErrorTimeout)
continue; // nothing received
if(result<0)
return result; // return error
if(!result)
goto retry; // negative acknowledge received
}
if(waitForBlockACK)
{
// wait for up to one second for block to be acknowledged...
int c = InChar(1000);
int result = ProcessResponse(c);
if(result<0)
return result; // return error
if(!result)
{
// negagtive acknowledge received...
if(c=='C' && !SendCRC)
{
// change to CRC mode if receiver sent 'C', and retry...
SendCRC = true;
goto change_mode;
}
goto retry;
}
}
else
{
// check for receiver sending a cancel byte...
int result = ProcessResponse(InChar(0));
if(result<0)
{
if(result!=ErrorTimeout)
return result; // return error if it's not a timeout
}
else
{
// ignore other responses
}
}
// block transferred OK...
++BlockNumber;
return dataSize;
retry:
while(InChar(500)>=0) // flush input buffers
{}
goto do_retry;
}
/**
Send data.
A zero sized block terminates the transfer.
@param data The data to transfer.
@param size Size of data.
@return Zero if successful, or a negative error value if failed.
@pre SendInitialise() must have been successful.
*/
int QymodemTx::SendData(const char* data, size_t size)
{
do
{
int result = SendBlock(data, size);
if(result<0)
return result;
data += result;
size -= result;
}
while(size);
return 0;
}
/**
Send an entire stread of data.
@param in The stream of data to send.
@return Zero if successful, or a negative error value if failed.
@pre SendInitialise() must have been successful.
*/
int QymodemTx::SendAll(InStream& in)
{
BlockNumber = 1; // first block to send is number one
size_t size;
do
{
// get data from input stream...
char data[1024];
int result = in.In(data,sizeof(data),&percent);
if(result<0)
return ErrorInputStreamError;
// send data...
size = result;
result = SendData(data,size);
if(result<0)
return result;
}
while(size); // end when no more data left
return 0;
}
/**
Construct the data for the first block of a Y-Modem transfer.
@param[out] buffer The buffer to store the constructed block. Size must be >=128 bytes.
@param fileName The name of the file being transferred.
@param fileSize The size of the file being transferred.
@return Zero if successful, or a negative error value if failed.
*/
int QymodemTx::MakeBlock0(char* buffer, const char* fileName, size_t fileSize)
{
// setup buffer for block 0...
char* out = buffer;
char* outEnd = buffer+128-1;
memset(buffer,0,128);
// copy file name to block data...
while(out<outEnd)
{
char c = *fileName++;
if(c>='A' && c<='Z')
c += 'a'-'A'; // convert name to lower-case
else if(c=='\\')
c = '/'; // convert back-slash to forward-slash
*out++ = c;
if(!c)
break; // end of name
}
// convert fileSize to a decimal number...
char length[sizeof(size_t)*3+1]; // buffer big enough to hold length as decimal number
char* lenEnd = length+sizeof(length);
char* len = lenEnd;
do
{
*--len = '0'+fileSize%10; // prepend digit to buffer
fileSize /= 10;
}
while(fileSize); // end when all digits done
// append file length to block data...
while(out<outEnd && len<lenEnd)
*out++ = *len++;
// check that buffer was big enough...
if(out>=outEnd)
return ErrorFileNameTooLong;
return 0; // OK
}
QymodemTx::QymodemTx(QextSerialPort& port)
: QymodemBase(port)
{
}
int QymodemTx::SendX(InStream& in, unsigned timeout, bool kMode)
{
Use1KBlocks = kMode;
int result = SendInitialise(timeout);
if(result<0)
return result;
return SendAll(in);
}
int QymodemTx::SendY(const char* fileName, size_t size, InStream& in, unsigned timeout)
{
Use1KBlocks = true;
char buffer[128];
int result = MakeBlock0(buffer,fileName,size);
if(result<0)
return result;
result = SendInitialise(timeout);
if(result<0 && result!=ErrorBlockRetriesExceded)
return result;
emit Information("Sending "+QString(fileName),QymodemTx::InfoSending);
BlockNumber = 0;
result = SendBlock(buffer,sizeof(buffer));
if(result<0)
return result;
result = InChar(SendTimeout);
if(result<0)
return result;
if(result!=ModeChar)
return ErrorReceiverNotBehaving;
result = SendAll(in);
if(result<0)
return result;
result = InChar(SendTimeout);
if(result<0)
return result;
if(result!=ModeChar)
return ErrorReceiverNotBehaving;
memset(buffer,0,sizeof(buffer));
BlockNumber = 0;
result = SendBlock(buffer,sizeof(buffer));
if(result<0)
return result;
return 0;
}