diff options
Diffstat (limited to 'upload')
| -rw-r--r-- | upload/xmodem.c | 2084 | ||||
| -rw-r--r-- | upload/xmodem.h | 308 |
2 files changed, 241 insertions, 2151 deletions
diff --git a/upload/xmodem.c b/upload/xmodem.c index dd471d7..a97327c 100644 --- a/upload/xmodem.c +++ b/upload/xmodem.c @@ -1,1879 +1,269 @@ -////////////////////////////////////////////////////////////////////////////// -// // -// _ // -// __ __ _ __ ___ ___ __| | ___ _ __ ___ ___ // -// \ \/ /| '_ ` _ \ / _ \ / _` | / _ \| '_ ` _ \ / __| // -// > < | | | | | || (_) || (_| || __/| | | | | | _| (__ // -// /_/\_\|_| |_| |_| \___/ \__,_| \___||_| |_| |_|(_)\___| // -// // -// // -////////////////////////////////////////////////////////////////////////////// -// // -// Copyright (c) 2012 by S.F.T. Inc. - All rights reserved // -// Use, copying, and distribution of this software are licensed according // -// to the GPLv2, LGPLv2, or BSD license, as appropriate (see COPYING) // -// // -////////////////////////////////////////////////////////////////////////////// - -// XMODEM adapted for arduino and POSIX systems. Windows code incomplete - +/* + * Copyright 2001-2010 Georges Menie (www.menie.org) + * All rights reserved. + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of the University of California, Berkeley nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND 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. + */ + +/* this code needs standard functions memcpy() and memset() + and input/output functions _inbyte() and _outbyte(). + the prototypes of the input/output functions are: + int _inbyte(unsigned short timeout); // msec timeout + void _outbyte(int c); + */ + +#include "crc16.h" #include "xmodem.h" -// special I/O when linked into 'SFTARDCAL' application -#ifdef SFTARDCAL -int my_read(SERIAL_TYPE iFile, void* pBuf, int cbBuf); -int my_write(SERIAL_TYPE iFile, const void* pBuf, int cbBuf); -void my_flush(SERIAL_TYPE iFile); -#endif // SFTARDCAL - -// internal structure definitions - -// Windows requires a different way of specifying structure packing -#ifdef WIN32 -#define PACKED -#pragma pack(push, 1) -#else // POSIX, ARDUINO -#define PACKED __attribute__((__packed__)) -#endif // WIN32 vs THE REST OF THE WORLD - -#define _SOH_ 1 /* start of packet - note XMODEM-1K uses '2' */ -#define _EOT_ 4 -#define _ENQ_ 5 -#define _ACK_ 6 -#define _NAK_ 21 /* NAK character */ -#define _CAN_ 24 /* CAN character CTRL+X */ - -/** \file xmodem.c - * \brief main source file for S.F.T. XMODEM library - * - * S.F.T. XMODEM library -**/ - -/** \ingroup xmodem_internal - * \brief Structure defining an XMODEM CHECKSUM packet - * -\code -typedef struct _XMODEM_BUF_ -{ - char cSOH; // ** SOH byte goes here ** - unsigned char aSEQ, aNotSEQ; // ** 1st byte = seq#, 2nd is ~seq# ** - char aDataBuf[128]; // ** the actual data itself! ** - unsigned char bCheckSum; // ** checksum gets 1 byte ** -} PACKED XMODEM_BUF; -\endcode - * -**/ -typedef struct _XMODEM_BUF_ { - char cSOH; ///< SOH byte goes here - unsigned char aSEQ, aNotSEQ; ///< 1st byte = seq#, 2nd is ~seq# - char aDataBuf[128]; ///< the actual data itself! - unsigned char bCheckSum; ///< checksum gets 1 byte -} PACKED XMODEM_BUF; - -/** \ingroup xmodem_internal - * \brief Structure defining an XMODEM CRC packet - * -\code -typedef struct _XMODEMC_BUF_ -{ - char cSOH; // ** SOH byte goes here ** - unsigned char aSEQ, aNotSEQ; // ** 1st byte = seq#, 2nd is ~seq# ** - char aDataBuf[128]; // ** the actual data itself! ** - unsigned short wCRC; // ** CRC gets 2 bytes, high endian ** -} PACKED XMODEMC_BUF; -\endcode - * -**/ -typedef struct _XMODEMC_BUF_ { - char cSOH; ///< SOH byte goes here - unsigned char aSEQ, aNotSEQ; ///< 1st byte = seq#, 2nd is ~seq# - char aDataBuf[128]; ///< the actual data itself! - unsigned short wCRC; ///< CRC gets 2 bytes, high endian -} PACKED XMODEMC_BUF; - -#ifdef WIN32 -// restore default packing -#pragma pack(pop) -#endif // WIN32 - -/** \ingroup xmodem_internal - * \brief Structure that identifies the XMODEM communication state - * -\code -typedef struct _XMODEM_ -{ - SERIAL_TYPE ser; // identifies the serial connection, data type is -OS-dependent - FILE_TYPE file; // identifies the file handle, data type is OS-dependent - union - { - XMODEM_BUF xbuf; // XMODEM CHECKSUM buffer - XMODEMC_BUF xcbuf; // XMODEM CRC buffer - } buf; // union of both buffers, total length 133 bytes - unsigned char bCRC; // non-zero for CRC, zero for checksum -} XMODEM; -\endcode - * -**/ -typedef struct _XMODEM_ { - SERIAL_TYPE - ser; ///< identifies the serial connection, data type is OS-dependent - FILE_TYPE file; ///< identifies the file handle, data type is OS-dependent - - union { - XMODEM_BUF xbuf; ///< XMODEM CHECKSUM buffer - XMODEMC_BUF xcbuf; ///< XMODEM CRC buffer - } buf; ///< union of both buffers, total length 133 bytes - - unsigned char bCRC; ///< non-zero for CRC, zero for checksum - -} XMODEM; - -#ifdef DEBUG_CODE -static char szERR[32]; // place for error messages, up to 16 characters - -const char* XMGetError(void) { - return szERR; -} -#endif // DEBUG_CODE - -#if defined(STAND_ALONE) && defined(DEBUG_CODE) -void debug_dump_buffer(int iDir, const void* pBuf, int cbBuf) { - int i1, i2; - const unsigned char *p1, *p2; - - if (cbBuf <= 0) { - return; - } - - p1 = p2 = (const unsigned char*)pBuf; - - for (i1 = 0, i2 = 0; i1 <= cbBuf; i1++, p1++) { - if (!i1 || i2 >= 16 || i1 == cbBuf) { - if (i1) { - while (i2 < 16) { - fputs(" ", stderr); // fill up spaces where data would be - i2++; - } - - fputs(" : ", stderr); - - while (p2 < p1) { - if (*p2 >= 32 && *p2 <= 127) { - fputc(*p2, stderr); - } else { - fputc('.', stderr); - } - - p2++; - } - - fputc('\n', stderr); - } - - if (!i1 && iDir > 0) { - fputs("--> ", stderr); - } else if (!i1 && iDir < 0) { - fputs("<-- ", stderr); - } else { - fputs(" ", stderr); - } - - i2 = 0; - p2 = p1; // make sure - } - - if (i1 < cbBuf) { - if (!i2) { - fprintf(stderr, "%02x: %02x", i1, *p1); - } else { - fprintf(stderr, ", %02x", *p1); - } - - i2++; +#define SOH 0x01 +#define STX 0x02 +#define EOT 0x04 +#define ACK 0x06 +#define NAK 0x15 +#define CAN 0x18 +#define CTRLZ 0x1A + +#define DLY_1S 1000 +#define MAXRETRANS 25 +#define TRANSMIT_XMODEM_1K + +static int check(int crc, const unsigned char* buf, int sz) { + if (crc) { + unsigned short crc = crc16_ccitt(buf, sz); + unsigned short tcrc = (buf[sz] << 8) + buf[sz + 1]; + if (crc == tcrc) + return 1; + } else { + int i; + unsigned char cks = 0; + for (i = 0; i < sz; ++i) { + cks += buf[i]; } + if (cks == buf[sz]) + return 1; } - fputc('\n', stderr); - fflush(stderr); + return 0; } -#endif // STAND_ALONE, DEBUG_CODE - -// char iBinaryTransfer = 0, iDisableRXOVER = 0; - -/** \ingroup xmodem_internal - * \brief Calculate checksum for XMODEM packet - * - * \param lpBuf A pointer to the XMODEM data buffer - * \param cbBuf The length of the XMODEM data buffer (typically 128) - * \return An unsigned char value to be assigned to the 'checksum' element in - *the XMODEM packet - * -**/ -unsigned char CalcCheckSum(const char* lpBuf, short cbBuf) { - short iC, i1; - iC = 0; - - for (i1 = 0; i1 < cbBuf; i1++) { - iC += lpBuf[i1]; - } - - return (unsigned char)(iC & 0xff); +static void flushinput(void) { + while (_inbyte(((DLY_1S)*3) >> 1) >= 0) + ; } -/** \ingroup xmodem_internal - * \brief Calculate checksum for XMODEM packet - * - * \param sVal An unsigned short integer to be made 'high endian' by flipping - *bytes (as needed) - * \return A (possibly) byte-flipped high-endian unsigned short integer - * - * This function assumes low-endian for Arduino, and performs a universal - *operation - * for 'indeterminate' architectures. -**/ -static unsigned short my_htons(unsigned short sVal) { - union { - unsigned char aVal[2]; - unsigned short sVal; - } a, b; - - // tweeked for size and speed. enjoy. - - b.sVal = sVal; - -#ifdef ARDUINO - - a.aVal[0] = b.aVal[1]; // no math involved, pre-optimized code - a.aVal[1] = b.aVal[0]; - -#else - - a.aVal[0] = (unsigned char)(sVal >> 8); // less optimized but universal code - a.aVal[1] = (unsigned char)(sVal & 0xff); - -#endif // ARDUINO - - return a.sVal; -} - -/** \ingroup xmodem_internal - * \brief Calculate 16-bit CRC for XMODEM packet - * - * \param lpBuf A pointer to the XMODEM data buffer - * \param cbBuf The length of the XMODEM data buffer (typically 128) - * \return A high-endian 16-bit (unsigned short) value to be assigned to the - *'CRC' element in the XMODEM packet - * - * This method uses the 'long way' which is SMALLER CODE for microcontrollers, - *but eats up a bit more CPU. - * Otherwise, you'd have to pre-build the 256 byte table and use "the table - *lookup" method. -**/ -unsigned short CalcCRC(const char* lpBuf, short cbBuf) { - unsigned short wCRC; - short i1, i2, iAX; - char cAL; - - // ** this function returns 2-byte string containing - // ** the CRC calculation result, as high endian - - wCRC = 0; - - for (i1 = 0; i1 < cbBuf; i1++) { - cAL = lpBuf[i1]; - - iAX = (unsigned short)cAL << 8; - - wCRC = iAX ^ wCRC; - - for (i2 = 0; i2 < 8; i2++) { - iAX = wCRC; - - if (iAX & 0x8000) { - wCRC <<= 1; - wCRC ^= 0x1021; - } else { - wCRC <<= 1; +int xmodemReceive(unsigned char* dest, int destsz) { + unsigned char + xbuff[1030]; /* 1024 for XModem 1k + 3 head chars + 2 crc + nul */ + unsigned char* p; + int bufsz, crc = 0; + unsigned char trychar = 'C'; + unsigned char packetno = 1; + int i, c, len = 0; + int retry, retrans = MAXRETRANS; + + for (;;) { + for (retry = 0; retry < 16; ++retry) { + if (trychar) + _outbyte(trychar); + if ((c = _inbyte((DLY_1S) << 1)) >= 0) { + switch (c) { + case SOH: + bufsz = 128; + goto start_recv; + case STX: + bufsz = 1024; + goto start_recv; + case EOT: + flushinput(); + _outbyte(ACK); + return len; /* normal end */ + case CAN: + if ((c = _inbyte(DLY_1S)) == CAN) { + flushinput(); + _outbyte(ACK); + return -1; /* canceled by remote */ + } + break; + default: + break; + } } } - } - - return my_htons(wCRC); -} - -// void WaitASecond() -//{ -//#ifdef ARDUINO -// delay(1000); -//#elif defined(WIN32) -// Sleep(1000); -//#else // -// usleep(1000000); -//#endif // ARDUINO -//} - -#ifndef ARDUINO -#ifdef WIN32 -#define MyMillis GetTickCount -#else // WIN32 - -/** \ingroup xmodem_internal - * \brief Return internal 'milliseconds' value for timing purposes - * - * \return A calculated 'milliseconds' value as an unsigned long integer - * - * This function returns the 'unsigned long' integer value for elapsed time - *based - * on the result of the 'gettimeofday()' API function. On 32-bit and Windows - *systems - * the value might wrap around, so you should be careful with your time - *comparisons (see the - * code _I_ wrote for the right way to do it). On 64-bit POSIX systems, this - *value will - * always increase.\n - * NOTE: Win32 defines this as a macro (see above) for the 'GetTickCount()' - *api, which - * returns a 32-bit value. POSIX x86 returns 32-bit, x64 returns - *64-bit. YMMV. -**/ -unsigned long MyMillis(void) { - struct timeval tv; - - gettimeofday(&tv, NULL); // 2nd parameter is obsolete anyway - - // NOTE: this won't roll over the way 'GetTickCount' does in WIN32 so I'll - // truncate it - // down to a 32-bit value to make it happen. Everything that uses - // 'MyGetTickCount' - // must handle this rollover properly using 'int' and not 'long' (or - // cast afterwards) - return ((unsigned int)((unsigned long)tv.tv_sec * 1000L + - (unsigned long)tv.tv_usec / 1000L)); -} -#endif // WIN32 -#endif // ARDUINO - -// Function GenerateSEQ (wSeq%) As String -// -// GenerateSEQ = Chr$(wSeq%) + Chr$(Not (wSeq%) And &HFF) -// -// End Function - -/** \ingroup xmodem_internal - * \brief Generate a sequence number pair, place into XMODEM_BUF - * - * \param pBuf A pointer to an XMODEM_BUF structure - * \param bSeq An unsigned char, typically cast from an unsigned long 'block - *number' - * - * This function generates the sequence pair for the XMODEM packet. The 'block - *number' - * is initially assigned a value of '1', and increases by 1 for each successful - *packet. - * That value is 'truncated' to a single byte and assigned as a sequence number - *for the - * packet itself. -**/ -void GenerateSEQ(XMODEM_BUF* pBuf, unsigned char bSeq) { - pBuf->aSEQ = bSeq; - pBuf->aNotSEQ = ~bSeq; -} - -/** \ingroup xmodem_internal - * \brief Generate a sequence number pair, place into XMODEMC_BUF (the CRC - *version) - * - * \param pBuf A pointer to an XMODEM_BUF structure - * \param bSeq An unsigned char, typically cast from an unsigned long 'block - *number' - * - * This function generates the sequence pair for the XMODEM packet. The 'block - *number' - * is initially assigned a value of '1', and increases by 1 for each successful - *packet. - * That value is 'truncated' to a single byte and assigned as a sequence number - *for the - * packet itself. -**/ -void GenerateSEQC(XMODEMC_BUF* pBuf, unsigned char bSeq) { - pBuf->aSEQ = bSeq; - pBuf->aNotSEQ = - (255 - bSeq); //~bSeq; these should be the same but for now I do this... -} - -/** \ingroup xmodem_internal - * \brief Get an XMODEM block from the serial device - * - * \param ser A 'SERIAL_TYPE' identifier for the serial connection - * \param pBuf A pointer to the buffer that receives the data - * \param cbSize The number of bytes/chars to read - * \return The number of bytes/chars read, 0 if timed out (no data), < 0 on - *error - * - * Call this function to read data from the serial port, specifying the number - *of - * bytes to read. This function times out after no data transferred (silence) - *for - * a period of 'SILENCE_TIMEOUT' milliseconds. This allows spurious data - *transfers - * to continue as long as there is LESS THAN 'SILENCE_TIMEOUT' between bytes, - *and - * also allows VERY SLOW BAUD RATES (as needed). However, if the transfer - *takes longer - * than '10 times SILENCE_TIMEOUT', the function will return the total number - *of bytes - * that were received within that time.\n - * The default value of 5 seconds, extended to 50 seconds, allows a worst-case - *baud - * rate of about 20. This should not pose a problem. If it does, edit the - *code. -**/ -short GetXmodemBlock(SERIAL_TYPE ser, char* pBuf, short cbSize) { - unsigned long ulCur; - short cb1; -// ** This function obtains a buffer of 'cbSize' bytes, ** -// ** waiting a maximum of 5 seconds (of silence) to get it. ** -// ** It returns the data within 'pBuf', returning the actual ** -// ** number of bytes transferred. ** - -#ifdef ARDUINO - char* p1; - short i1; - - p1 = pBuf; - cb1 = 0; - - ulCur = millis(); - ser->setTimeout(SILENCE_TIMEOUT); // 5 seconds [of silence] - - for (i1 = 0; i1 < cbSize; i1++) { - if (ser->readBytes(p1, 1) != - 1) // 5 seconds of "silence" is what fails this - { - break; - } - - cb1++; - p1++; - - if ((millis() - ulCur) > - (unsigned long)(10L * SILENCE_TIMEOUT)) // 10 times SILENCE TIMEOUT for - // TOTAL TIMEOUT - { - break; // took too long, I'm going now - } - } - -#elif defined(SFTARDCAL) -#ifndef WIN32 - struct pollfd aFD[2]; -#endif // WIN32 - int i1; - unsigned long ulStart; - - ulStart = ulCur = MyMillis(); - - cb1 = 0; - - do { -#ifndef WIN32 - aFD[0].fd = ser; - aFD[0].events = POLLIN | POLLERR; - aFD[0].revents = 0; - - i1 = poll(aFD, 1, 100); - if (!i1) { + if (trychar == 'C') { + trychar = NAK; continue; } - - if (i1 < 0) { - fprintf(stderr, "poll error %d\n", errno); - return -1; - } -#endif // WIN32 - -#ifdef WIN32 - if (my_pollin(ser) > 0) -#else // WIN32 - if (aFD[0].revents & POLLIN) -#endif // WIN32 - { - i1 = my_read(ser, pBuf + cb1, cbSize - cb1); - - if (i1 > 0) { - cb1 += i1; - ulCur = MyMillis(); - } - } else { - MySleep(1); - } - } while (!QuitFlag() && cb1 < cbSize && - (MyMillis() - ulCur) < SILENCE_TIMEOUT && - (MyMillis() - ulStart) < (unsigned long)10L * SILENCE_TIMEOUT); - -#elif defined(WIN32) - -#error no win32 code yet - -#else // POSIX - unsigned long ulStart; - char* p1; - int i1, i2; - - if (fcntl(ser, F_SETFL, O_NONBLOCK) == -1) { - static int iFailFlag = 0; - - if (!iFailFlag) { - fprintf(stderr, "Warning: 'fcntl(O_NONBLOCK)' failed, errno = %d\n", - errno); - fflush(stderr); - iFailFlag = 1; - } - } - - p1 = pBuf; - cb1 = 0; - - ulStart = ulCur = MyMillis(); - - for (i1 = 0; i1 < cbSize; i1++) { - while ((i2 = read(ser, p1, 1)) != 1) { - if (i2 < 0 && errno != EAGAIN) { - // read error - exit now - // return cb1; // how many bytes I actually read - goto the_end; - } else { - usleep(1000); // 1 msec - - if ((MyMillis() - ulCur) > SILENCE_TIMEOUT || // too much silence? - (MyMillis() - ulStart) > - 10 * SILENCE_TIMEOUT) // too long for transfer - { - // return cb1; // finished (return how many bytes I actually - // read) - goto the_end; + flushinput(); + _outbyte(CAN); + _outbyte(CAN); + _outbyte(CAN); + return -2; /* sync error */ + + start_recv: + if (trychar == 'C') + crc = 1; + trychar = 0; + p = xbuff; + *p++ = c; + for (i = 0; i < (bufsz + (crc ? 1 : 0) + 3); ++i) { + if ((c = _inbyte(DLY_1S)) < 0) + goto reject; + *p++ = c; + } + + if (xbuff[1] == (unsigned char)(~xbuff[2]) && + (xbuff[1] == packetno || xbuff[1] == (unsigned char)packetno - 1) && + check(crc, &xbuff[3], bufsz)) { + if (xbuff[1] == packetno) { + register int count = destsz - len; + if (count > bufsz) + count = bufsz; + if (count > 0) { + memcpy(&dest[len], &xbuff[3], count); + len += count; } + ++packetno; + retrans = MAXRETRANS + 1; } - } - - // here it succeeds - - cb1++; - p1++; - - if ((MyMillis() - ulStart) > - 10 * SILENCE_TIMEOUT) // 10 times SILENCE TIMEOUT for TOTAL TIMEOUT - { - break; // took too long, I'm going now - } - } - -the_end: - -#if defined(STAND_ALONE) && defined(DEBUG_CODE) - fprintf(stderr, "GetXmodemBlock - request %d, read %d errno=%d\n", cbSize, - cb1, errno); - fflush(stderr); - //#ifdef DEBUG_CODE - debug_dump_buffer(-1, pBuf, cb1); -//#endif // DEBUG_CODE -#endif // STAND_ALONE - -#endif // ARDUINO - - return cb1; // what I actually read -} - -/** \ingroup xmodem_internal - * \brief Write a single character to the serial device - * - * \param ser A 'SERIAL_TYPE' identifier for the serial connection - * \param bVal The byte to send - * \return The number of bytes/chars written, or < 0 on error - * - * Call this function to write one byte of data to the serial port. Typically - * this is used to send things like an ACK or NAK byte. -**/ -int WriteXmodemChar(SERIAL_TYPE ser, unsigned char bVal) { - int iRval; -#ifdef ARDUINO - - iRval = ser->write(bVal); -// ser->flush(); // force sending it - -#elif defined(SFTARDCAL) - char buf[2]; // use size of '2' to avoid warnings about array size of '1' - - buf[0] = (char)bVal; - return (short)my_write(ser, buf, 1); - -#elif defined(WIN32) - -#error no win32 code yet - -#else // POSIX - char buf[2]; // use size of '2' to avoid warnings about array size of '1' - - if (fcntl(ser, F_SETFL, 0) == -1) // set blocking mode - { - static int iFailFlag = 0; - - if (!iFailFlag) { - fprintf(stderr, "Warning: 'fcntl(O_NONBLOCK)' failed, errno = %d\n", - errno); - iFailFlag = 1; - } - } - - buf[0] = bVal; // in case args are passed by register - - iRval = write(ser, buf, 1); - -#if defined(STAND_ALONE) && defined(DEBUG_CODE) - fprintf(stderr, "WriteXmodemChar - returns %d\n", iRval); - if (iRval > 0) { - debug_dump_buffer(1, buf, 1); - } -#endif // STAND_ALONE, DEBUG_CODE -#endif // ARDUINO - - return iRval; -} - -/** \ingroup xmodem_internal - * \brief Send an XMODEM block via the serial device - * - * \param ser A 'SERIAL_TYPE' identifier for the serial connection - * \param pBuf A pointer to the buffer that receives the data - * \param cbSize The number of bytes/chars to write - * \return The number of bytes/chars written, < 0 on error - * - * Call this function to write data via the serial port, specifying the number - *of - * bytes to write. -**/ -int WriteXmodemBlock(SERIAL_TYPE ser, const void* pBuf, int cbSize) { - int iRval; -#ifdef ARDUINO - - iRval = ser->write((const uint8_t*)pBuf, cbSize); -// ser->flush(); // force sending it before returning - -#elif defined(SFTARDCAL) - - return (short)my_write(ser, pBuf, cbSize); - -#elif defined(WIN32) - -#error no win32 code yet - -#else // POSIX - - if (fcntl(ser, F_SETFL, 0) == -1) // set blocking mode - { - static int iFailFlag = 0; - - if (!iFailFlag) { - fprintf(stderr, "Warning: 'fcntl(O_NONBLOCK)' failed, errno = %d\n", - errno); - fflush(stderr); - iFailFlag = 1; - } - } - - iRval = write(ser, pBuf, cbSize); - -#if defined(STAND_ALONE) && defined(DEBUG_CODE) - fprintf(stderr, "\r\nWriteXmodemBlock - returns %d\n", iRval); - fflush(stderr); - - if (iRval > 0) { - debug_dump_buffer(1, pBuf, cbSize); - } -#endif // STAND_ALONE, DEBUG_CODE -#endif - - return iRval; -} - -/** \ingroup xmodem_internal - * \brief Read all input from the serial port until there is 1 second of - *'silence' - * - * \param ser A 'SERIAL_TYPE' identifier for the serial connection - * - * Call this function to read ALL data from the serial port, until there is a - *period - * with no data (i.e. 'silence') for 1 second. At that point the function will - *return.\n - * Some operations require that any bad data be flushed out of the input to - *prevent - * synchronization problems. By using '1 second of silence' it forces - *re-synchronization - * to occur in one shot, with the possible exception of VERY noisy lines. The - *down side - * is that it may slow down transfers with a high data rate. -**/ -void XModemFlushInput(SERIAL_TYPE ser) { -#ifdef ARDUINO - unsigned long ulStart; - - ulStart = millis(); - - do { - if (ser->available()) { - ser->read(); // don't care about the data - ulStart = millis(); // reset time - } else { - delay(1); - } - - } while ((millis() - ulStart) < 1000); - -#elif defined(SFTARDCAL) - - my_flush(ser); - -#elif defined(WIN32) - -#error no win32 code yet - -#else // POSIX - unsigned long ulStart; - int i1; -#ifdef DEBUG_CODE - unsigned char buf[16]; - int cbBuf; -#else // DEBUG_CODE - unsigned char buf[2]; -#endif // DEBUG_CODE - - if (fcntl(ser, F_SETFL, O_NONBLOCK) == -1) { - static int iFailFlag = 0; - - if (!iFailFlag) { - fprintf(stderr, "Warning: 'fcntl(O_NONBLOCK)' failed, errno = %d\n", - errno); - iFailFlag = 1; - } - } - - ulStart = MyMillis(); -#ifdef DEBUG_CODE - cbBuf = 0; -#endif // DEBUG_CODE - while ((MyMillis() - ulStart) < 1000) { -#ifdef DEBUG_CODE - i1 = read(ser, &(buf[cbBuf]), 1); -#else // DEBUG_CODE - i1 = read(ser, buf, 1); -#endif // DEBUG_CODE - if (i1 == 1) { -#if defined(STAND_ALONE) && defined(DEBUG_CODE) - cbBuf++; - if (cbBuf >= sizeof(buf)) { - debug_dump_buffer(-1, buf, cbBuf); - cbBuf = 0; + if (--retrans <= 0) { + flushinput(); + _outbyte(CAN); + _outbyte(CAN); + _outbyte(CAN); + return -3; /* too many retry error */ } -#endif // STAND_ALONE, DEBUG_CODE - ulStart = MyMillis(); - } else { - usleep(1000); + _outbyte(ACK); + continue; } + reject: + flushinput(); + _outbyte(NAK); } - -#if defined(STAND_ALONE) && defined(DEBUG_CODE) - if (cbBuf > 0) { - debug_dump_buffer(-1, buf, cbBuf); - } -#endif // STAND_ALONE, DEBUG_CODE - -#endif // ARDUINO -} - -/** \ingroup xmodem_internal - * \brief Terminate the XMODEM connection - * - * \param pX A pointer to the 'XMODEM' object identifying the transfer - * - * Call this function prior to ending the XMODEM transfer. Currently the only - * thing it does is flush the input. -**/ -void XmodemTerminate(XMODEM* pX) { - XModemFlushInput(pX->ser); - - // TODO: close files? -} - -/** \ingroup xmodem_internal - * \brief Validate the sequence number of a received XMODEM block - * - * \param pX A pointer to an 'XMODEM_BUF' - * \param bSeq The expected sequence number (block & 255) - * \return A zero value on success, non-zero otherwise - * - * Call this function to validate a packet's sequence number against the block - *number -**/ -short ValidateSEQ(XMODEM_BUF* pX, unsigned char bSeq) { - return pX->aSEQ != 255 - pX->aNotSEQ || // ~(pX->aNotSEQ) || - pX->aSEQ != bSeq; // returns TRUE if not valid } -/** \ingroup xmodem_internal - * \brief Validate the sequence number of a received XMODEM block (CRC version) - * - * \param pX A pointer to an 'XMODEMC_BUF' - * \param bSeq The expected sequence number (block & 255) - * \return A zero value on success, non-zero otherwise - * - * Call this function to validate a packet's sequence number against the block - *number -**/ -short ValidateSEQC(XMODEMC_BUF* pX, unsigned char bSeq) { - return pX->aSEQ != 255 - pX->aNotSEQ || // ~(pX->aNotSEQ) || - pX->aSEQ != bSeq; // returns TRUE if not valid -} - -/** \ingroup xmodem_internal - * \brief Generic function to receive a file via XMODEM (CRC or Checksum) - * - * \param pX A pointer to an 'XMODEM_BUF' with valid bCRC, ser, and file - *members - * \return A zero value on success, negative on error, positive on cancel - * - * The calling function will need to poll for an SOH from the server using 'C' - *and 'NAK' - * characters (as appropriate) until an SOH is received. That value must be - *assigned - * to the 'buf' union (as appropriate), and the bCRC member assigned to - *non-zero if - * the server responded to 'C', or zero if it responded to 'NAK'. With the - *bCRC, - * ser, and file members correctly assigned, call THIS function to receive - *content - * via XMODEM and write it to 'file'.\n - * This function will return zero on success, a negative value on error, and a - *positive - * value if the transfer was canceled by the server. -**/ -int ReceiveXmodem(XMODEM* pX) { -#ifdef WIN32 - DWORD cbWrote; -#endif // WIN32 - int ecount, ec2; - long etotal, filesize, block; - unsigned char cY; // the char to send in response to a packet -// NOTE: to allow debugging the CAUSE of an xmodem block's failure, i1, i2, and -// i3 -// are assigned to function return values and reported in error messages. -#ifdef DEBUG_CODE - short i1, i2, i3; -#define DEBUG_I1 i1 = -#define DEBUG_I2 i2 = -#define DEBUG_I3 i3 = -#else // DEBUG_CODE -#define DEBUG_I1 /*normally does nothing*/ -#define DEBUG_I2 /*normally does nothing*/ -#define DEBUG_I3 /*normally does nothing*/ -#endif // DEBUG_CODE - - ecount = 0; - etotal = 0; - filesize = 0; - block = 1; - - // ** already got the first 'SOH' character on entry to this function ** - - // Form2.Show 0 '** modeless show of form2 (CANSEND) ** - // Form2!Label1.FloodType = 0 - // Form2.Caption = "* XMODEM(Checksum) BINARY RECEIVE *" - // Form2!Label1.Caption = "Errors: 0 Bytes: 0" - - pX->buf.xbuf.cSOH = (char)1; // assumed already got this, put into buffer - - do { - if (!pX->bCRC && - ((DEBUG_I1 GetXmodemBlock(pX->ser, ((char*)&(pX->buf.xbuf)) + 1, - sizeof(pX->buf.xbuf) - 1)) != - sizeof(pX->buf.xbuf) - 1 || - (DEBUG_I2 ValidateSEQ(&(pX->buf.xbuf), block & 255)) || - (DEBUG_I3 CalcCheckSum(pX->buf.xbuf.aDataBuf, - sizeof(pX->buf.xbuf.aDataBuf)) != - pX->buf.xbuf.bCheckSum))) { -// did not receive properly -// TODO: deal with repeated packet, sequence number for previous packet - -#ifdef DEBUG_CODE - sprintf(szERR, "A%ld,%d,%d,%d,%d,%d", block, i1, i2, i3, - pX->buf.xbuf.aSEQ, pX->buf.xbuf.aNotSEQ); -//#ifdef STAND_ALONE -// fprintf(stderr, "TEMPORARY (csum): seq=%x, ~seq=%x i1=%d, i2=%d, -// i3=%d\n", pX->buf.xbuf.aSEQ, pX->buf.xbuf.aNotSEQ, i1, i2, i3); -//#endif // STAND_ALONE -#endif // DEBUG_CODE - - XModemFlushInput(pX->ser); // necessary to avoid problems - - cY = _NAK_; // send NAK (to get the checksum version) - ecount++; // for this packet - etotal++; - } else if (pX->bCRC && - ((DEBUG_I1 GetXmodemBlock(pX->ser, ((char*)&(pX->buf.xcbuf)) + 1, - sizeof(pX->buf.xcbuf) - 1)) != - sizeof(pX->buf.xcbuf) - 1 || - (DEBUG_I2 ValidateSEQC(&(pX->buf.xcbuf), block & 255)) || - (DEBUG_I3 CalcCRC(pX->buf.xcbuf.aDataBuf, - sizeof(pX->buf.xbuf.aDataBuf)) != - pX->buf.xcbuf.wCRC))) { -// did not receive properly -// TODO: deal with repeated packet, sequence number for previous packet - -#ifdef DEBUG_CODE - sprintf(szERR, "B%ld,%d,%d,%d,%d,%d", block, i1, i2, i3, - pX->buf.xcbuf.aSEQ, pX->buf.xcbuf.aNotSEQ); -//#ifdef STAND_ALONE -// fprintf(stderr, "TEMPORARY (CRC): seq=%x, ~seq=%x i1=%d, i2=%d, -// i3=%d\n", pX->buf.xcbuf.aSEQ, pX->buf.xcbuf.aNotSEQ, i1, i2, i3); -//#endif // STAND_ALONE -#endif // DEBUG_CODE - - XModemFlushInput(pX->ser); // necessary to avoid problems - - if (block > 1) { - cY = _NAK_; // TODO do I need this? - } else { - cY = - 'C'; // send 'CRC' NAK (the character 'C') (to get the CRC version) - } - ecount++; // for this packet - etotal++; - } else { -#ifdef ARDUINO - if (pX->file.write((const uint8_t*)&(pX->buf.xbuf.aDataBuf), - sizeof(pX->buf.xbuf.aDataBuf)) != - sizeof(pX->buf.xbuf.aDataBuf)) { - return -2; // write error on output file - } -#elif defined(WIN32) - cbWrote = 0; - if (!WriteFile(pX->file, &(pX->buf.xbuf.aDataBuf), - sizeof(pX->buf.xbuf.aDataBuf), &cbWrote, NULL) || - cbWrote != sizeof(pX->buf.xbuf.aDataBuf)) { - XmodemTerminate(pX); - return -2; // write error on output file - } -#else // ARDUINO - if (write(pX->file, &(pX->buf.xbuf.aDataBuf), - sizeof(pX->buf.xbuf.aDataBuf)) != - sizeof(pX->buf.xbuf.aDataBuf)) { - XmodemTerminate(pX); - return -2; // write error on output file +int xmodemTransmit(unsigned char* src, int srcsz) { + unsigned char + xbuff[1030]; /* 1024 for XModem 1k + 3 head chars + 2 crc + nul */ + int bufsz, crc = -1; + unsigned char packetno = 1; + int i, c, len = 0; + int retry; + + for (;;) { + for (retry = 0; retry < 16; ++retry) { + if ((c = _inbyte((DLY_1S) << 1)) >= 0) { + switch (c) { + case 'C': + crc = 1; + goto start_trans; + case NAK: + crc = 0; + goto start_trans; + case CAN: + if ((c = _inbyte(DLY_1S)) == CAN) { + _outbyte(ACK); + flushinput(); + return -1; /* canceled by remote */ + } + break; + default: + break; + } } -#endif // ARDUINO - cY = _ACK_; // send ACK - block++; - filesize += sizeof(pX->buf.xbuf.aDataBuf); // TODO: need method to avoid - // extra crap at end of file - ecount = 0; // zero out error count for next packet } - -#if defined(STAND_ALONE) || defined(SFTARDCAL) - fprintf(stderr, - "block %ld %ld bytes %d errors\r" -#ifndef SFTARDCAL - "\n" -#endif // SFTARDCAL - , - block - 1, filesize, ecount); -#endif // STAND_ALONE - - ec2 = 0; // ** error count #2 ** - - while (ecount < TOTAL_ERROR_COUNT && - ec2 < ACK_ERROR_COUNT) // ** loop to get SOH or EOT character ** - { - WriteXmodemChar(pX->ser, cY); // ** output appropriate command char ** - - if (GetXmodemBlock(pX->ser, &(pX->buf.xbuf.cSOH), 1) == 1) { - if (pX->buf.xbuf.cSOH == _CAN_) // ** CTRL-X 'CAN' - terminate - { - XmodemTerminate(pX); - return 1; // terminated - } else if (pX->buf.xbuf.cSOH == _EOT_) // ** EOT - end - { - WriteXmodemChar( - pX->ser, - _ACK_); // ** send an ACK (most XMODEM protocols expect THIS) - // WriteXmodemChar(pX->ser, _ENQ_); // ** send an ENQ - - return 0; // I am done - } else if (pX->buf.xbuf.cSOH == _SOH_) // ** SOH - sending next packet - { - break; // leave this loop + _outbyte(CAN); + _outbyte(CAN); + _outbyte(CAN); + flushinput(); + return -2; /* no sync */ + + for (;;) { + start_trans: +#ifdef TRANSMIT_XMODEM_1K + xbuff[0] = STX; + bufsz = 1024; +#else + xbuff[0] = SOH; + bufsz = 128; +#endif + xbuff[1] = packetno; + xbuff[2] = ~packetno; + c = srcsz - len; + if (c > bufsz) + c = bufsz; + if (c > 0) { + memset(&xbuff[3], 0, bufsz); + memcpy(&xbuff[3], &src[len], c); + if (c < bufsz) + xbuff[3 + c] = CTRLZ; + if (crc) { + unsigned short ccrc = crc16_ccitt(&xbuff[3], bufsz); + xbuff[bufsz + 3] = (ccrc >> 8) & 0xFF; + xbuff[bufsz + 4] = ccrc & 0xFF; } else { - // TODO: deal with repeated packet, i.e. previous sequence number - - XModemFlushInput(pX->ser); // necessary to avoid problems (since the - // character was unexpected) - // if I was asking for the next block, and got an unexpected - // character, do a NAK; otherwise, - // just repeat what I did last time - - if (cY == _ACK_) // ACK - { - cY = _NAK_; // NACK + unsigned char ccks = 0; + for (i = 3; i < bufsz + 3; ++i) { + ccks += xbuff[i]; } - - ec2++; + xbuff[bufsz + 3] = ccks; } - } else { - ecount++; // increase total error count, and try writing the 'ACK' or - // 'NACK' again - } - } - - if (ec2 >= ACK_ERROR_COUNT) // wasn't able to get a packet - { - break; - } - - } while (ecount < TOTAL_ERROR_COUNT); - - XmodemTerminate(pX); - return 1; // terminated -} - -/** \ingroup xmodem_internal - * \brief Generic function to send a file via XMODEM (CRC or Checksum) - * - * \param pX A pointer to an 'XMODEM_BUF' with valid ser, and file members, and - *the polled - * 'NAK' value assigned to the cSOH member (first byte) within the 'buf' union. - * \return A zero value on success, negative on error, positive on cancel - * - * The calling function will need to poll for a 'C' or NAK from the client (as - *appropriate) - * and assign that character to the cSOH member in the 'buf' union (either xbuf - *or xcbuf since - * the 'cSOH' will always be the first byte). Then call this function to send - *content - * via XMODEM from 'file'.\n - * It is important to record the NAK character before calling this function - *since the 'C' or - * 'NAK' value will be used to determine whether to use CRC or CHECKSUM.\n - * This function will return zero on success, a negative value on error, and a - *positive - * value if the transfer was canceled by the receiver. -**/ -int SendXmodem(XMODEM* pX) { -#ifdef WIN32 - DWORD cbRead; -#endif // WIN32 - int ecount, ec2; - short i1; - long etotal, filesize, filepos, block; - - ecount = 0; - etotal = 0; - filesize = 0; - filepos = 0; - block = 1; - - pX->bCRC = - 0; // MUST ASSIGN TO ZERO FIRST or XMODEM-CHECKSUM may not work properly - -// ** already got first 'NAK' character on entry as pX->buf.xbuf.cSOH ** - -#ifdef ARDUINO - - filesize = pX->file.size(); - -#else // ARDUINO - -#ifdef WIN32 - filesize = (long)SetFilePointer(pX->file, 0, NULL, FILE_END); -#else // WIN32 - filesize = (long)lseek(pX->file, 0, SEEK_END); -#endif // WIN32 - if (filesize < 0) // not allowed - { -#ifdef STAND_ALONE - fputs("SendXmodem fail (file size)\n", stderr); -#endif // STAND_ALONE - return -1; - } - -#ifdef WIN32 - SetFilePointer(pX->file, 0, NULL, FILE_BEGIN); -#else // WIN32 - lseek(pX->file, 0, SEEK_SET); // position at beginning -#endif // WIN32 - -#endif // ARDUINO - - do { - // ** depending on type of transfer, place the packet - // ** into pX->buf with all fields appropriately filled. - - if (filepos >= filesize) // end of transfer - { - for (i1 = 0; i1 < 8; i1++) { - WriteXmodemChar(pX->ser, - _EOT_); // ** send an EOT marking end of transfer - - if (GetXmodemBlock(pX->ser, &(pX->buf.xbuf.cSOH), 1) != - 1) // this takes up to 5 seconds - { - // nothing returned - try again? - // break; // for now I loop, uncomment to bail out - } else if (pX->buf.xbuf.cSOH == - _ENQ_ // an 'ENQ' (apparently some expect this) - || pX->buf.xbuf.cSOH == _ACK_ // an 'ACK' (most XMODEM - // implementations expect - // this) - || pX->buf.xbuf.cSOH == _CAN_) // CTRL-X = TERMINATE - { - // both normal and 'abnormal' termination. - break; + for (retry = 0; retry < MAXRETRANS; ++retry) { + for (i = 0; i < bufsz + 4 + (crc ? 1 : 0); ++i) { + _outbyte(xbuff[i]); + } + if ((c = _inbyte(DLY_1S)) >= 0) { + switch (c) { + case ACK: + ++packetno; + len += bufsz; + goto start_trans; + case CAN: + if ((c = _inbyte(DLY_1S)) == CAN) { + _outbyte(ACK); + flushinput(); + return -1; /* canceled by remote */ + } + break; + case NAK: + default: + break; + } + } } - } - - XmodemTerminate(pX); - -#if defined(STAND_ALONE) && defined(DEBUG_CODE) - fprintf(stderr, "SendXmodem return %d\n", i1 >= 8 ? 1 : 0); -#endif // STAND_ALONE - return i1 >= 8 ? 1 : 0; // return 1 if receiver choked on the 'EOT' - // marker, else 0 for 'success' - } - -// TODO: progress indicator [can be LCD for arduino, blinky lights, ??? and -// of course stderr for everyone else] -// If filesize& <> 0 Then Form2!Label1.FloodPercent = 100 * filepos& / -// filesize& - -#if defined(STAND_ALONE) || defined(SFTARDCAL) - fprintf(stderr, - "block %ld %ld of %ld bytes %d errors\r" -#ifndef SFTARDCAL - "\n" -#endif // SFTARDCAL - , - block, filepos, filesize, ecount); -#endif // STAND_ALONE - - if (pX->buf.xbuf.cSOH != 'C' // XMODEM CRC - && pX->buf.xbuf.cSOH != (char)_NAK_) // NAK - { - // increase error count, bail if it's too much - - ec2++; - } - -#ifdef ARDUINO - pX->file.seek(filepos); // in case I'm doing a 'retry' and I have to - // re-read part of the file -#elif defined(WIN32) - SetFilePointer(pX->file, filepos, NULL, FILE_BEGIN); -#else // ARDUINO - lseek(pX->file, filepos, SEEK_SET); // same reason as above -#endif // ARDUINO - - // fortunately, xbuf and xcbuf are the same through the end of 'aDataBuf' so - // I can read the file NOW using 'xbuf' for both CRC and CHECKSUM versions - - if ((filesize - filepos) >= sizeof(pX->buf.xbuf.aDataBuf)) { -#ifdef ARDUINO - i1 = pX->file.read(pX->buf.xbuf.aDataBuf, sizeof(pX->buf.xcbuf.aDataBuf)); -#elif defined(WIN32) - cbRead = 0; - if (!ReadFile(pX->file, pX->buf.xbuf.aDataBuf, - sizeof(pX->buf.xbuf.aDataBuf), &cbRead, NULL)) { - i1 = -1; - } else { - i1 = (int)cbRead; - } -#else // ARDUINO - i1 = - read(pX->file, pX->buf.xbuf.aDataBuf, sizeof(pX->buf.xcbuf.aDataBuf)); -#endif // ARDUINO - - if (i1 != sizeof(pX->buf.xcbuf.aDataBuf)) { - // TODO: read error - send a ctrl+x ? - } - } else { - memset(pX->buf.xcbuf.aDataBuf, '\x1a', - sizeof(pX->buf.xcbuf.aDataBuf)); // fill with ctrl+z which is what - // the spec says -#ifdef ARDUINO - i1 = pX->file.read(pX->buf.xbuf.aDataBuf, filesize - filepos); -#elif defined(WIN32) - cbRead = 0; - if (!ReadFile(pX->file, pX->buf.xbuf.aDataBuf, filesize - filepos, - &cbRead, NULL)) { - i1 = -1; + _outbyte(CAN); + _outbyte(CAN); + _outbyte(CAN); + flushinput(); + return -4; /* xmit error */ } else { - i1 = (int)cbRead; - } -#else // ARDUINO - i1 = read(pX->file, pX->buf.xbuf.aDataBuf, filesize - filepos); -#endif // ARDUINO - - if (i1 != (filesize - filepos)) { - // TODO: read error - send a ctrl+x ? - } - } - - if (pX->buf.xbuf.cSOH == - 'C' || // XMODEM CRC 'NAK' (first time only, typically) - ((pX->buf.xbuf.cSOH == _ACK_ || pX->buf.xbuf.cSOH == _NAK_) && - pX->bCRC)) // identifies ACK/NACK with XMODEM CRC - { - pX->bCRC = 1; // make sure (only matters the first time, really) - - // calculate the CRC, assign to the packet, and then send it - - pX->buf.xcbuf.cSOH = 1; // must send SOH as 1st char - pX->buf.xcbuf.wCRC = - CalcCRC(pX->buf.xcbuf.aDataBuf, sizeof(pX->buf.xcbuf.aDataBuf)); - - GenerateSEQC(&(pX->buf.xcbuf), (unsigned char)block); - - // send it - - i1 = WriteXmodemBlock(pX->ser, &(pX->buf.xcbuf), sizeof(pX->buf.xcbuf)); - if (i1 != sizeof(pX->buf.xcbuf)) // write error - { - // TODO: handle write error (send ctrl+X ?) - } - } else if (pX->buf.xbuf.cSOH == _NAK_ || // 'NAK' (checksum method, may - // also be with CRC method) - (pX->buf.xbuf.cSOH == _ACK_ && - !pX->bCRC)) // identifies ACK with XMODEM CHECKSUM - { - pX->bCRC = 0; // make sure (this ALSO allows me to switch modes on error) - - // calculate the CHECKSUM, assign to the packet, and then send it - - pX->buf.xbuf.cSOH = 1; // must send SOH as 1st char - pX->buf.xbuf.bCheckSum = - CalcCheckSum(pX->buf.xbuf.aDataBuf, sizeof(pX->buf.xbuf.aDataBuf)); - - GenerateSEQ(&(pX->buf.xbuf), (unsigned char)block); - - // send it - - i1 = WriteXmodemBlock(pX->ser, &(pX->buf.xbuf), sizeof(pX->buf.xbuf)); - if (i1 != sizeof(pX->buf.xbuf)) // write error - { - // TODO: handle write error (send ctrl+X ?) - } - } - - ec2 = 0; - - while (ecount < TOTAL_ERROR_COUNT && - ec2 < ACK_ERROR_COUNT) // loop to get ACK or NACK - { - if (GetXmodemBlock(pX->ser, &(pX->buf.xbuf.cSOH), 1) == 1) { - if (pX->buf.xbuf.cSOH == _CAN_) // ** CTRL-X - terminate - { - XmodemTerminate(pX); - - return 1; // terminated - } else if (pX->buf.xbuf.cSOH == _NAK_ || // ** NACK - pX->buf.xbuf.cSOH == 'C') // ** CRC NACK - { - break; // exit inner loop and re-send packet - } else if (pX->buf.xbuf.cSOH == _ACK_) // ** ACK - sending next packet - { - filepos += sizeof(pX->buf.xbuf.aDataBuf); - block++; // increment file position and block count - - break; // leave inner loop, send NEXT packet - } else { - XModemFlushInput(pX->ser); // for now, do this here too - ec2++; + for (retry = 0; retry < 10; ++retry) { + _outbyte(EOT); + if ((c = _inbyte((DLY_1S) << 1)) == ACK) + break; } - } else { - ecount++; // increase total error count, then loop back and re-send - // packet - break; + flushinput(); + return (c == ACK) ? len : -5; } } - - if (ec2 >= ACK_ERROR_COUNT) { - break; // that's it, I'm done with this - } - - } while ( - ecount < - TOTAL_ERROR_COUNT /* * 2 */); // twice error count allowed for sending - - // TODO: progress indicator - // If filesize& <> 0 And filepos& <= filesize& Then - // Form2!Label1.FloodPercent = 100 * filepos& / filesize& - // Else - // Form2!Label1.FloodPercent = 100 - // End If - - // ** at this point it is important to indicate the errors - // ** and flush all buffers, and terminate process! - - XmodemTerminate(pX); -#ifdef STAND_ALONE - fputs("SendXmodem fail (total error count)\n", stderr); -#endif // STAND_ALONE - return -2; // exit on error -} - -/** \ingroup xmodem_internal - * \brief Calling function for ReceiveXmodem - * - * \param pX A pointer to an 'XMODEM_BUF' with valid ser, and file members - * \return A zero value on success, negative on error, positive on cancel - * - * This is a generic 'calling function' for ReceiveXmodem that checks for - * a response to 'C' and 'NAK' characters, and sets up the XMODEM transfer - * for either CRC or CHECKSUM mode.\n - * This function will return zero on success, a negative value on error, and a - *positive - * value if the transfer was canceled by the receiver. -**/ -int XReceiveSub(XMODEM* pX) { - int i1; - - // start with CRC mode [try 8 times to get CRC] - - pX->bCRC = 1; - - for (i1 = 0; i1 < 8; i1++) { - WriteXmodemChar(pX->ser, 'C'); // start with NAK for XMODEM CRC - - if (GetXmodemBlock(pX->ser, &(pX->buf.xbuf.cSOH), 1) == 1) { - if (pX->buf.xbuf.cSOH == _SOH_) // SOH - packet is on its way - { - return ReceiveXmodem(pX); - } else if (pX->buf.xbuf.cSOH == - _EOT_) // an EOT [blank file? allow this?] - { - return 0; // for now, do this - } else if (pX->buf.xbuf.cSOH == _CAN_) // cancel - { - return 1; // canceled - } - } - } - - pX->bCRC = 0; - - // try again, this time using XMODEM CHECKSUM - for (i1 = 0; i1 < 8; i1++) { - WriteXmodemChar(pX->ser, _NAK_); // switch to NAK for XMODEM Checksum - - if (GetXmodemBlock(pX->ser, &(pX->buf.xbuf.cSOH), 1) == 1) { - if (pX->buf.xbuf.cSOH == _SOH_) // SOH - packet is on its way - { - return ReceiveXmodem(pX); - } else if (pX->buf.xbuf.cSOH == - _EOT_) // an EOT [blank file? allow this?] - { - return 0; // for now, do this - } else if (pX->buf.xbuf.cSOH == _CAN_) // cancel - { - return 1; // canceled - } - } - } - - XmodemTerminate(pX); - - return -3; // fail -} - -/** \ingroup xmodem_internal - * \brief Calling function for SendXmodem - * - * \param pX A pointer to an 'XMODEM_BUF' with valid ser, and file members - * \return A zero value on success, negative on error, positive on cancel - * - * This is a generic 'calling function' for SendXmodem that checks for polls by - *the - * receiver, and places the 'NAK' or 'C' character into the 'buf' member of the - *XMODEM - * structure so that SendXmodem can use the correct method, either CRC or - *CHECKSUM mode.\n - * This function will return zero on success, a negative value on error, and a - *positive - * value if the transfer was canceled by the receiver. -**/ -int XSendSub(XMODEM* pX) { - unsigned long ulStart; - -// waiting up to 30 seconds for transfer to start. this is part of the spec? - -#ifdef ARDUINO - ulStart = millis(); -#else // ARDUINO - ulStart = MyMillis(); -#endif // ARDUINO - - do { - if (GetXmodemBlock(pX->ser, &(pX->buf.xbuf.cSOH), 1) == 1) { - if (pX->buf.xbuf.cSOH == 'C' || // XMODEM CRC - pX->buf.xbuf.cSOH == _NAK_) // NAK - XMODEM CHECKSUM - { -#if defined(STAND_ALONE) && defined(DEBUG_CODE) - fprintf(stderr, "Got %d, continuing\n", pX->buf.xbuf.cSOH); -#endif // STAND_ALONE - return SendXmodem(pX); - } else if (pX->buf.xbuf.cSOH == _CAN_) // cancel - { -#ifdef STAND_ALONE - fputs("XSendSub fail (cancel)\n", stderr); -#endif // STAND_ALONE - return 1; // canceled - } - } - } -#ifdef ARDUINO - while ((short)(millis() - ulStart) < 30000); // 30 seconds -#else // ARDUINO - while ((int)(MyMillis() - ulStart) < 30000); -#endif // ARDUINO - - XmodemTerminate(pX); - -#ifdef STAND_ALONE - fputs("XSendSub fail (timeout)\n", stderr); -#endif // STAND_ALONE - return -3; // fail -} - -// typedef struct _XMODEM_ -//{ -// SERIAL_TYPE ser; -// FILE_TYPE file; -// -// union -// { -// XMODEM_BUF xbuf; -// XMODEMC_BUF xcbuf; -// } buf; // 133 bytes -// -// unsigned char bCRC; // non-zero for CRC, zero for checksum -// -//} __attribute__((__packed__)) XMODEM; - -#ifdef ARDUINO - -short XReceive(SDClass* pSD, HardwareSerial* pSer, const char* szFilename) { - short iRval; - XMODEM xx; - - memset(&xx, 0, sizeof(xx)); - - xx.ser = pSer; - - if (pSD->exists((char*)szFilename)) { - pSD->remove((char*)szFilename); - } - - xx.file = pSD->open((char*)szFilename, FILE_WRITE); - if (!xx.file) { - return -9; // can't create file - } - - iRval = XReceiveSub(&xx); - - xx.file.close(); - - if (iRval) { - WriteXmodemChar(pSer, _CAN_); // cancel (make sure) - - pSD->remove((char*)szFilename); // delete file on error } - - return iRval; -} - -int XSend(SDClass* pSD, HardwareSerial* pSer, const char* szFilename) { - short iRval; - XMODEM xx; - - memset(&xx, 0, sizeof(xx)); - - xx.ser = pSer; - - xx.file = pSD->open(szFilename, FILE_READ); - if (!xx.file) { - return -9; // can't open file - } - - iRval = XSendSub(&xx); - - xx.file.close(); - - return iRval; -} - -#else // ARDUINO - -int XReceive(SERIAL_TYPE hSer, const char* szFilename, int nMode) { - int iRval; - XMODEM xx; -#if !defined(ARDUINO) && !defined(WIN32) - int iFlags; -#endif // !ARDUINO - -#ifdef DEBUG_CODE - szERR[0] = 0; -#endif // DEBUG_CODE - memset(&xx, 0, sizeof(xx)); - - xx.ser = hSer; - -#ifdef WIN32 - DeleteFile(szFilename); - - nMode = nMode; // to avoid unused parameter warnings - // TODO: translate 'nMode' into file attributes? for now ignore it - xx.file = CreateFile(szFilename, GENERIC_READ | GENERIC_WRITE, 0, NULL, - CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); - - if (xx.file == INVALID_HANDLE_VALUE) -#else // WIN32 - unlink(szFilename); // make sure it does not exist, first - xx.file = open(szFilename, O_CREAT | O_TRUNC | O_WRONLY, nMode); - - if (xx.file == -1) // bad file handle on POSIX systems -#endif // WIN32 - { -#ifdef STAND_ALONE - fprintf(stderr, "XReceive fail \"%s\" errno=%d\n", szFilename, errno); -#endif // STAND_ALONE - return -9; // can't create file - } - -#if !defined(ARDUINO) && !defined(WIN32) - iFlags = fcntl(hSer, F_GETFL); -#endif // !ARDUINO - - iRval = XReceiveSub(&xx); - -#if !defined(ARDUINO) && !defined(WIN32) - if (iFlags == -1 || fcntl(hSer, F_SETFL, iFlags) == -1) { - fprintf(stderr, - "Warning: 'fcntl' call to restore flags failed, errno=%d\n", - errno); - } -#endif // !ARDUINO - -#ifdef WIN32 - CloseHandle(xx.file); -#else // WIN32 - close(xx.file); -#endif // WIN32 - - if (iRval) { -#ifdef WIN32 - DeleteFile(szFilename); -#else // WIN32 - unlink(szFilename); // delete file on error -#endif // WIN32 - } - -#if defined(STAND_ALONE) && defined(DEBUG_CODE) - fprintf(stderr, "XReceive returns %d\n", iRval); -#endif // STAND_ALONE - return iRval; -} - -int XSend(SERIAL_TYPE hSer, const char* szFilename) { - int iRval; - XMODEM xx; -#if !defined(ARDUINO) && !defined(WIN32) - int iFlags; -#endif // !ARDUINO - -#ifdef DEBUG_CODE - szERR[0] = 0; -#endif // DEBUG_CODE - memset(&xx, 0, sizeof(xx)); - - xx.ser = hSer; - -#ifdef WIN32 - xx.file = - CreateFile(szFilename, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL); - - if (xx.file == INVALID_HANDLE_VALUE) -#else // WIN32 - xx.file = open(szFilename, O_RDONLY, 0); - - if (xx.file == -1) // bad file handle on POSIX systems -#endif // WIN32 - { -#ifdef STAND_ALONE - fprintf(stderr, "XSend fail \"%s\" errno=%d\n", szFilename, errno); -#endif // STAND_ALONE - return -9; // can't open file - } - -#if !defined(ARDUINO) && !defined(WIN32) - iFlags = fcntl(hSer, F_GETFL); -#endif // !ARDUINO - - iRval = XSendSub(&xx); - -#if !defined(ARDUINO) && !defined(WIN32) - if (iFlags == -1 || fcntl(hSer, F_SETFL, iFlags) == -1) { - fprintf(stderr, - "Warning: 'fcntl' call to restore flags failed, errno=%d\n", - errno); - } -#endif // !ARDUINO - -#ifdef WIN32 - CloseHandle(xx.file); -#else // WIN32 - close(xx.file); -#endif // WIN32 - -#if defined(STAND_ALONE) && defined(DEBUG_CODE) - fprintf(stderr, "XSend returning %d\n", iRval); -#endif // STAND_ALONE - return iRval; -} - -#endif // ARDUINO - -#if defined(STAND_ALONE) && !defined(SFTARDCAL) - -static const char szSER[] = "/dev/ttyU0"; - -#include <termios.h> - -/** \ingroup xmodem_standalone - * \brief Terminal configuration (POSIX only) - * - * \param iFile The open file handle for the serial connection - * \param iBaud The baud rate for the connection - * \param iParity The parity, < 0 for even, > 0 for odd, 0 for none - * \param iBits The number of bits (5, 6, 7, 8) - * \param iStop The number of stop bits (1 or 2) - * - * This is a sample tty config function to CORRECTLY set up a serial connection - * to allow XMODEM transfer. The important details here are the use of the - * 'termios' structure and utility functions to DISABLE all of the things that - * would otherwise cause trouble, like CRLF translation, CTRL+C handling, etc. -**/ -void ttyconfig(int iFile, int iBaud, int iParity, int iBits, int iStop) { - int i1; - struct termios sIOS; - - i1 = fcntl(iFile, F_GETFL); - - i1 |= O_NONBLOCK; // i1 &= ~O_NONBLOCK); // turn OFF non-blocking? - - fcntl(iFile, F_SETFL, i1); - - if (!tcgetattr(iFile, &sIOS)) { - cfsetspeed(&sIOS, iBaud); - sIOS.c_cflag &= ~(CSIZE | PARENB | CS5 | CS6 | CS7 | CS8); - sIOS.c_cflag |= - iBits == 5 ? CS5 : iBits == 6 ? CS6 : iBits == 7 ? CS7 - : CS8; // 8 is default - if (iStop == 2) { - sIOS.c_cflag |= CSTOPB; - } else { - sIOS.c_cflag &= ~CSTOPB; - } - - sIOS.c_cflag &= - ~CRTSCTS; // hardware flow control _DISABLED_ (so I can do the reset) - sIOS.c_cflag |= CLOCAL; // ignore any modem status lines - - if (!iParity) { - sIOS.c_cflag &= ~(PARENB | PARODD); - } else if (iParity > 0) // odd - { - sIOS.c_cflag |= (PARENB | PARODD); - } else // even (negative) - { - sIOS.c_cflag &= PARODD; - sIOS.c_cflag |= PARENB; - } - - // sIOS.c_iflag |= IGNCR; // ignore CR - - // do not translate characters or xon/xoff and ignore break - sIOS.c_iflag &= ~(IGNBRK | INLCR | IGNCR | ICRNL | IXON | IXOFF | IXANY | - IMAXBEL | ISTRIP); // turn these off - -#if defined(__FreeBSD__) - sIOS.c_oflag &= ~(OPOST | ONLCR | OCRNL | TABDLY | ONOEOT | ONOCR | - ONLRET); // FreeBSD version -#else // Linux? YMMV - sIOS.c_oflag &= ~(OPOST | ONLCR | OCRNL | TABDLY | ONOCR | - ONLRET); // turn these off too (see man termios) -#endif // FBSD vs Linux - -// make sure echoing is disabled and control chars aren't translated or omitted -#if defined(__FreeBSD__) - sIOS.c_lflag &= ~(ECHO | ECHOKE | ECHOE | ECHONL | ECHOPRT | ECHOCTL | - ICANON | IEXTEN | ISIG | ALTWERASE); -#else // Linux? YMMV - sIOS.c_lflag &= ~(ECHO | ECHOKE | ECHOE | ECHONL | ECHOPRT | ECHOCTL | - ICANON | IEXTEN | ISIG); -#endif // FBSD vs Linux - sIOS.c_cc[VMIN] = 0; // ensures no 'grouping' of input - sIOS.c_cc[VTIME] = 0; // immediate return - - if (tcsetattr(iFile, TCSANOW, &sIOS)) { - fprintf(stderr, "error %d setting attributes\n", errno); - } - } else { - fprintf(stderr, "error %d getting attributes\n", errno); - } -} - -/** \ingroup xmodem_standalone - * \brief Arduino 'reset' function - * - * \param iFile The open file handle for the serial connection - * - * The Arduino serial port typically has the DTR/RTS lines configured so that - * a proper 'pulse' will cause a hardware reset of the device. This function - *will - * send that pulse to the Arduino, and wait for a short time afterwards for the - * hardware reset to take place. -**/ -void reset_arduino(int iFile) { - unsigned int sFlags; - unsigned long ulStart; - int i1; - - // toggle the RTS and DTR high, low, then high - so much easier via - // POSIX-compatible OS! - - ioctl(iFile, TIOCMGET, &sFlags); - - sFlags &= ~(TIOCM_DTR | TIOCM_RTS); // the high to low transition discharges - // the capacitor (signal is inverted on - // board) - if (ioctl(iFile, TIOCMSET, &sFlags) < 0) { - fprintf(stderr, "WARNING: ioctl() returns < 0, errno=%d (%xH)\n", errno, - errno); - } - - usleep( - 250000); // avrdude does this for 50 msecs, my change has it at 50msecs - - sFlags |= TIOCM_DTR | TIOCM_RTS; // leave it in THIS state when I'm done - if (ioctl(iFile, TIOCMSET, &sFlags) < 0) { - fprintf(stderr, "WARNING: ioctl() returns < 0, errno=%d (%xH)\n", errno, - errno); - } - - usleep(50000); // avrdude does this for 50 msecs (no change) - - ulStart = MyMillis(); - - // flush whatever is there, (5 seconds) - - while ((MyMillis() - ulStart) < 5000) { - i1 = read(iFile, &i1, 1); - if (i1 == 1) { - ulStart = MyMillis(); - } else { - usleep(1000); - } - } -} - -int main(int argc, char* argv[]) { - int hSer; - char tbuf[256]; - int i1, iSR = 0; - - if (argc < 3) { - fputs("Usage: [prog] [S|R] filename\n", stderr); - return 1; - } - - if (argv[1][0] == 'R' || argv[1][1] == 'r') { - iSR = -1; - } else if (argv[1][0] == 'S' || argv[1][1] == 's') { - iSR = 1; - } else if (argv[1][0] == 'X' || argv[1][1] == 'x') { - iSR = 0; // test function - } else { - fputs("Usage: [prog] [S|R] filename (b)\n", stderr); - return 1; - } - - hSer = open(szSER, (O_RDWR | O_NONBLOCK), 0); - if (hSer == -1) { - fprintf(stderr, "Unable to open \"%s\" errno=%d\n", szSER, errno); - return 3; - } - - fputs("TTYCONFIG\n", stderr); - ttyconfig(hSer, 9600, 0, 8, 1); - - reset_arduino(hSer); - - fprintf(stderr, "Sleeping for 10 seconds to allow reset\n"); - - // usleep(10000000); - for (i1 = 0; i1 < 10; i1++) { - XModemFlushInput(hSer); - } - - for (i1 = 0; i1 < 3; i1++) { - sprintf(tbuf, "X%c%s", argv[1][0], argv[2]); - - fprintf(stderr, "writing: \"%s\"\n", tbuf); - strcat(tbuf, "\r"); - WriteXmodemBlock(hSer, tbuf, strlen(tbuf)); - - fputs("flush input\n", stderr); - XModemFlushInput(hSer); - - // wait for an LF response - - if (iSR > 0) { - fputs("XSEND\n", stderr); - if (XSend(hSer, argv[2])) { - fputs("ERROR\n", stderr); - } else { - fputs("SUCCESS!\n", stderr); - i1 = 0; - break; - } - } else if (iSR < 0) { - fputs("XRECEIVE\n", stderr); - if (XReceive(hSer, argv[2], 0664)) { - fputs("ERROR\n", stderr); - } else { - fputs("SUCCESS!\n", stderr); - i1 = 0; - break; - } - } else { - // test function - XModemFlushInput(hSer); // continue doing this - break; // done (once only) - } - } - - fputs("EXIT\n", stderr); - close(hSer); - - return i1 ? 1 : -1; } -#endif // STAND_ALONE diff --git a/upload/xmodem.h b/upload/xmodem.h index 37bed1a..62346f1 100644 --- a/upload/xmodem.h +++ b/upload/xmodem.h @@ -1,310 +1,10 @@ #ifndef XMODEM_H #define XMODEM_H -////////////////////////////////////////////////////////////////////////////// -// // -// _ _ // -// __ __ _ __ ___ ___ __| | ___ _ __ ___ | |__ // -// \ \/ /| '_ ` _ \ / _ \ / _` | / _ \| '_ ` _ \ | '_ \ // -// > < | | | | | || (_) || (_| || __/| | | | | | _ | | | | // -// /_/\_\|_| |_| |_| \___/ \__,_| \___||_| |_| |_|(_)|_| |_| // -// // -// // -////////////////////////////////////////////////////////////////////////////// -// // -// Copyright (c) 2012 by S.F.T. Inc. - All rights reserved // -// Use, copying, and distribution of this software are licensed according // -// to the LGPLv2.1, or a BSD-like license, as appropriate (see below) // -// // -////////////////////////////////////////////////////////////////////////////// +#include "legato.h" -#ifdef ARDUINO -/** \mainpage S.F.T. XMODEM library (ARDUINO version) - * - * Copyright (c) 2012 by S.F.T. Inc. - All rights reserved\n - * - * The source files include DOXYGEN SUPPORT to properly document the library - * Please excuse the additional comments necessary to make this work. - * Instead, build the doxygen output and view the documentation, as - * well as the code itself WITHOUT all of the doxygen markup comments. - * \n - * \n - * This library was designed to work with POSIX-compliant operating systems - * such as Linux, FreeBSD, and OSX, and also on Arduino microcontrollers. - * The intent was to provide an identical code base for both ends of the - * XMODEM transfer, compilable as either C or C++ code for maximum flexibility. - * - * Normally you will only need to use one of these two functions:\n - * \n - * \ref XSend() - send a file via XMODEM\n - * \ref XReceive() - receive a file via XMODEM\n - * \n - * The rest of the documentation was provided to help you debug any problems, - * or even to write your own library (as appropriate).\n - * - * LICENSE - * - * This software is licensed under either the LGPLv2 or a BSD-like license. - * For more information, see\n - * http://opensource.org/licenses/BSD-2-Clause\n - * http://www.gnu.org/licenses/lgpl-2.1.html\n - * and the above copyright notice.\n - * \n - * In short, you may use this software anyway you like, provided that you - * do not hold S.F.T. Inc. responsible for consequential or inconsequential - * damages resulting from use, modification, abuse, or anything else done - * with this software, and you include the appropriate license (either LGPLv2 - * or a BSD-like license) and comply with the requirements of said license.\n - * So, if you use a BSD-like license, you can copy the license template at - * the abovementioned URL and sub in the copyright notice as shown above. - * Or, you may use an LGPLv2 license, and then provide source files with a - * re-distributed or derived work (including a complete re-write with this - * library as a template). A link back to the original source, of course, - * would be appreciated but is not required. -**/ -#else // ARDUINO -/** \mainpage S.F.T. XMODEM library - * - * Copyright (c) 2012 by S.F.T. Inc. - All rights reserved\n - * - * The source files include DOXYGEN SUPPORT to properly document the library - * Please excuse the additional comments necessary to make this work. - * Instead, build the doxygen output and view the documentation, as - * well as the code itself WITHOUT all of the doxygen markup comments. - * \n - * \n - * This library was designed to work with POSIX-compliant operating systems - * such as Linux, FreeBSD, and OSX, and also on Arduino microcontrollers. - * The intent was to provide an identical code base for both ends of the - * XMODEM transfer, compilable as either C or C++ code for maximum flexibility. - * - * Normally you will only need to use one of these two functions:\n - * \n - * \ref XSend() - send a file via XMODEM\n - * \ref XReceive() - receive a file via XMODEM\n - * \n - * The rest of the documentation was provided to help you debug any problems, - * or even to write your own library (as appropriate).\n - * - * LICENSE - * - * This software is licensed under either the LGPLv2 or a BSD-like license. - * For more information, see\n - * http://opensource.org/licenses/BSD-2-Clause\n - * http://www.gnu.org/licenses/lgpl-2.1.html\n - * and the above copyright notice.\n - * \n - * In short, you may use this software anyway you like, provided that you - * do not hold S.F.T. Inc. responsible for consequential or inconsequential - * damages resulting from use, modification, abuse, or anything else done - * with this software, and you include the appropriate license (either LGPLv2 - * or a BSD-like license) and comply with the requirements of said license.\n - * So, if you use a BSD-like license, you can copy the license template at - * the abovementioned URL and sub in the copyright notice as shown above. - * Or, you may use an LGPLv2 license, and then provide source files with a - * re-distributed or derived work (including a complete re-write with this - * library as a template). A link back to the original source, of course, - * would be appreciated but is not required. -**/ -#endif // ARDUINO - -/** \file xmodem.h - * \brief main header file for S.F.T. XMODEM library - * - * S.F.T. XMODEM library -**/ - -/** \defgroup xmodem_api XModem API - * high-level API functions -*/ - -/** \defgroup xmodem_internal XModem Internal - * internal support functions -*/ - -#ifdef STANDALONE -/** \defgroup xmodem_standalone XModem Stand-alone - * internal 'standalone' functions, an example for POSIX implementation -*/ -#endif // STANDALONE - -// determine if arduino build, define ARDUINO if not already done - -#if defined(__AVR__) || defined(AVR) || defined(__AVR) || defined(__AVR_ARCH__) -#ifndef ARDUINO -#define ARDUINO /* hopefully I cover all compiler variations */ -#endif // ARDUINO -#endif // __AVR__ - -#include <stdlib.h> - -// required include files -#ifdef ARDUINO -// arduino includes -#include <Arduino.h> -#include <SD.h> -#include <HardwareSerial.h> /* may already be included by 'Arduino.h' */ -#include <avr/pgmspace.h> - -#elif WIN32 -// win32 includes -#include <Windows.h> -#include <io.h> -#else // POSIX -// posix includes -#include <stdio.h> -#include <stdlib.h> -#include <unistd.h> -#include <errno.h> -#include <fcntl.h> -#include <sys/time.h> -#include <sys/ioctl.h> // for IOCTL definitions -#include <memory.h> -#endif // OS-dependent includes - -// required per-OS definitions -#ifdef ARDUINO - -// file and serial types for Arduino -#define FILE_TYPE File -#define SERIAL_TYPE HardwareSerial* - -#elif defined(WIN32) // WINDOWS - -// file and serial types for WIN32 -#define FILE_TYPE HANDLE -#define SERIAL_TYPE HANDLE - -#else // POSIX - -// file and serial types for POSIX -#define FILE_TYPE int -#define SERIAL_TYPE int - -#endif // ARDUINO - -// common definitions - -#define SILENCE_TIMEOUT 5000 /* 5 seconds */ -#define TOTAL_ERROR_COUNT 32 -#define ACK_ERROR_COUNT 8 - -// Arduino build uses C++ so I must define functions properly - -#ifdef ARDUINO - -/** \ingroup xmodem_api - * \brief Receive a file using XMODEM protocol (ARDUINO version) - * - * \param pSD A pointer to an SDClass object, such as &SD (the default SD - *library object is 'SD') - * \param pSer A pointer to a HardwareSerial object, such as &Serial - * \param szFilename A pointer to a (const) 0-byte terminated string containing - *the file name - * \return A value of zero on success, negative on failure, positive if - *canceled - * - * Call this function to receive a file, passing the SD card's initialized - *SDClass object pointer, - * and the pointer to the 'HardwareSerial' object to be used for serial - *communication, and the - * name of the file to create from the XMODEM stream. The function will return - *a value of zero on - * success. On failure or cancelation, the file will be deleted.\n - * If the specified file exists before calling this function, it will be - *overwritten. If you do not - * want to unconditionally overwrite an existing file, you should test to see - *if it exists first - * using the SD library. - * -**/ -short XReceive(SDClass* pSD, HardwareSerial* pSer, const char* szFilename); - -/** \ingroup xmodem_api - * \brief Send a file using XMODEM protocol (ARDUINO version) - * - * \param pSD A pointer to an SDClass object, such as &SD (the default SD - *library object is 'SD') - * \param pSer A pointer to a HardwareSerial object, such as &Serial - * \param szFilename A pointer to a (const) 0-byte terminated string containing - *the file name - * \return A value of zero on success, negative on failure, positive if - *canceled - * - * Call this function to send a file, passing the SD card's initialized SDClass - *object pointer, - * and the pointer to the 'HardwareSerial' object to be used for serial - *communication, and the - * name of the file to send via the XMODEM stream. The function will return a - *value of zero on - * success. If the file does not exist, the function will return a 'failure' - *value and cancel - * the transfer. - * -**/ -int XSend(SDClass* pSD, HardwareSerial* pSer, const char* szFilename); - -#ifdef DEBUG_CODE -const char* XMGetError(void); -#endif // DEBUG_CODE - -#else // ARDUINO - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** \ingroup xmodem_api - * \brief Receive a file using XMODEM protocol - * - * \param hSer A 'HANDLE' for the open serial connection - * \param szFilename A pointer to a (const) 0-byte terminated string containing - *the file name - * \param nMode The file mode to be used on create (RWX bits) - * \return A value of zero on success, negative on failure, positive if - *canceled - * - * Call this function to receive a file, passing the handle to the open serial - *connection, and the - * name and mode of the file to create from the XMODEM stream. The function - *will return a value of zero on - * success. On failure or cancelation, the file will be deleted.\n - * If the specified file exists before calling this function, it will be - *overwritten. If you do not - * want to unconditionally overwrite an existing file, you should test to see - *if it exists first. - * -**/ -int XReceive(SERIAL_TYPE hSer, const char* szFilename, int nMode); - -/** \ingroup xmodem_api - * \brief Send a file using XMODEM protocol - * - * \param hSer A 'HANDLE' for the open serial connection - * \param szFilename A pointer to a (const) 0-byte terminated string containing - *the file name - * \return A value of zero on success, negative on failure, positive if - *canceled - * - * Call this function to receive a file, passing the handle to the open serial - *connection, and the - * name and mode of the file to send via the XMODEM stream. The function will - *return a value of zero on - * success. If the file does not exist, the function will return a 'failure' - *value and cancel - * the transfer. - * -**/ -int XSend(SERIAL_TYPE hSer, const char* szFilename); - -#ifdef DEBUG_CODE -const char* XMGetError(void); -#endif // DEBUG_CODE - -#ifdef __cplusplus -}; -#endif // __cplusplus - -#endif // ARDUINO +int xmodemTransmit(unsigned char* src, int srcsz); +uint8_t _inbyte(unsigned short timeout); +void _outbyte(uint8_t c); #endif |