summaryrefslogtreecommitdiff
path: root/components/utilities
diff options
context:
space:
mode:
authorBernard Xiong <[email protected]>2013-01-08 05:05:02 -0800
committerBernard Xiong <[email protected]>2013-01-08 05:05:02 -0800
commit72782e920325808bbc58fc2344fc52033479b627 (patch)
tree45badbfa9818b8d1722463949beba0f88d1cbd9f /components/utilities
parentb3cf278502e605fa03861a2da5685b4c8d72879e (diff)
convert end of line
Diffstat (limited to 'components/utilities')
-rw-r--r--components/utilities/zmodem/crc.h258
-rw-r--r--components/utilities/zmodem/rz.c790
-rw-r--r--components/utilities/zmodem/sz.c632
-rw-r--r--components/utilities/zmodem/zcore.c854
-rw-r--r--components/utilities/zmodem/zdef.h128
-rw-r--r--components/utilities/zmodem/zdevice.c156
-rw-r--r--components/utilities/zmodem/zstart.c230
7 files changed, 1524 insertions, 1524 deletions
diff --git a/components/utilities/zmodem/crc.h b/components/utilities/zmodem/crc.h
index df0c5dd41a..fd11c1960a 100644
--- a/components/utilities/zmodem/crc.h
+++ b/components/utilities/zmodem/crc.h
@@ -1,129 +1,129 @@
-/*
- * crc calculation stuff
- */
-
-/* crctab calculated by Mark G. Mendel, Network Systems Corporation */
-static unsigned short crctab[256] = {
- 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
- 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
- 0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
- 0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
- 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
- 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
- 0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
- 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
- 0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
- 0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
- 0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
- 0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
- 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
- 0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
- 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
- 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
- 0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
- 0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
- 0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
- 0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
- 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
- 0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
- 0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
- 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
- 0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
- 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
- 0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
- 0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
- 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
- 0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
- 0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
- 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
-};
-
-/*
- * updcrc macro derived from article Copyright (C) 1986 Stephen Satchell.
- * NOTE: First srgument must be in range 0 to 255.
- * Second argument is referenced twice.
- *
- * Programmers may incorporate any or all code into their programs,
- * giving proper credit within the source. Publication of the
- * source routines is permitted so long as proper credit is given
- * to Stephen Satchell, Satchell Evaluations and Chuck Forsberg,
- * Omen Technology.
- */
-
-#define updcrc16(cp, crc) ( crctab[((crc >> 8) & 255)] ^ (crc << 8) ^ cp)
-
-/*
- * Copyright (C) 1986 Gary S. Brown. You may use this program, or
- * code or tables extracted from it, as desired without restriction.
- */
-
-/* First, the polynomial itself and its table of feedback terms. The */
-/* polynomial is */
-/* X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0 */
-/* Note that we take it "backwards" and put the highest-order term in */
-/* the lowest-order bit. The X^32 term is "implied"; the LSB is the */
-/* X^31 term, etc. The X^0 term (usually shown as "+1") results in */
-/* the MSB being 1. */
-
-/* Note that the usual hardware shift register implementation, which */
-/* is what we're using (we're merely optimizing it by doing eight-bit */
-/* chunks at a time) shifts bits into the lowest-order term. In our */
-/* implementation, that means shifting towards the right. Why do we */
-/* do it this way? Because the calculated CRC must be transmitted in */
-/* order from highest-order term to lowest-order term. UARTs transmit */
-/* characters in order from LSB to MSB. By storing the CRC this way, */
-/* we hand it to the UART in the order low-byte to high-byte; the UART */
-/* sends each low-bit to hight-bit; and the result is transmission bit */
-/* by bit from highest- to lowest-order term without requiring any bit */
-/* shuffling on our part. Reception works similarly. */
-
-/* The feedback terms table consists of 256, 32-bit entries. Notes: */
-/* */
-/* The table can be generated at runtime if desired; code to do so */
-/* is shown later. It might not be obvious, but the feedback */
-/* terms simply represent the results of eight shift/xor opera- */
-/* tions for all combinations of data and CRC register values. */
-/* */
-/* The values must be right-shifted by eight bits by the "updcrc" */
-/* logic; the shift must be unsigned (bring in zeroes). On some */
-/* hardware you could probably optimize the shift in assembler by */
-/* using byte-swap instructions. */
-
-static unsigned long cr3tab[] = { /* CRC polynomial 0xedb88320 */
-0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
-0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
-0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
-0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
-0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
-0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
-0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
-0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
-0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
-0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
-0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
-0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
-0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
-0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
-0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
-0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
-0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
-0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
-0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
-0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
-0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
-0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
-0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
-0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
-0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
-0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
-0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
-0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
-0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
-0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
-0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
-0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
-};
-
-#define updcrc32(b, c) (cr3tab[((int)c ^ b) & 0xff] ^ ((c >> 8) & 0x00FFFFFF))
-
-/* End of crc.c */
+/*
+ * crc calculation stuff
+ */
+
+/* crctab calculated by Mark G. Mendel, Network Systems Corporation */
+static unsigned short crctab[256] = {
+ 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
+ 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
+ 0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
+ 0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
+ 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
+ 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
+ 0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
+ 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
+ 0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
+ 0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
+ 0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
+ 0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
+ 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
+ 0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
+ 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
+ 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
+ 0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
+ 0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
+ 0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
+ 0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
+ 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
+ 0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
+ 0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
+ 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
+ 0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
+ 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
+ 0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
+ 0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
+ 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
+ 0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
+ 0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
+ 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
+};
+
+/*
+ * updcrc macro derived from article Copyright (C) 1986 Stephen Satchell.
+ * NOTE: First srgument must be in range 0 to 255.
+ * Second argument is referenced twice.
+ *
+ * Programmers may incorporate any or all code into their programs,
+ * giving proper credit within the source. Publication of the
+ * source routines is permitted so long as proper credit is given
+ * to Stephen Satchell, Satchell Evaluations and Chuck Forsberg,
+ * Omen Technology.
+ */
+
+#define updcrc16(cp, crc) ( crctab[((crc >> 8) & 255)] ^ (crc << 8) ^ cp)
+
+/*
+ * Copyright (C) 1986 Gary S. Brown. You may use this program, or
+ * code or tables extracted from it, as desired without restriction.
+ */
+
+/* First, the polynomial itself and its table of feedback terms. The */
+/* polynomial is */
+/* X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0 */
+/* Note that we take it "backwards" and put the highest-order term in */
+/* the lowest-order bit. The X^32 term is "implied"; the LSB is the */
+/* X^31 term, etc. The X^0 term (usually shown as "+1") results in */
+/* the MSB being 1. */
+
+/* Note that the usual hardware shift register implementation, which */
+/* is what we're using (we're merely optimizing it by doing eight-bit */
+/* chunks at a time) shifts bits into the lowest-order term. In our */
+/* implementation, that means shifting towards the right. Why do we */
+/* do it this way? Because the calculated CRC must be transmitted in */
+/* order from highest-order term to lowest-order term. UARTs transmit */
+/* characters in order from LSB to MSB. By storing the CRC this way, */
+/* we hand it to the UART in the order low-byte to high-byte; the UART */
+/* sends each low-bit to hight-bit; and the result is transmission bit */
+/* by bit from highest- to lowest-order term without requiring any bit */
+/* shuffling on our part. Reception works similarly. */
+
+/* The feedback terms table consists of 256, 32-bit entries. Notes: */
+/* */
+/* The table can be generated at runtime if desired; code to do so */
+/* is shown later. It might not be obvious, but the feedback */
+/* terms simply represent the results of eight shift/xor opera- */
+/* tions for all combinations of data and CRC register values. */
+/* */
+/* The values must be right-shifted by eight bits by the "updcrc" */
+/* logic; the shift must be unsigned (bring in zeroes). On some */
+/* hardware you could probably optimize the shift in assembler by */
+/* using byte-swap instructions. */
+
+static unsigned long cr3tab[] = { /* CRC polynomial 0xedb88320 */
+0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
+0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
+0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
+0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
+0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
+0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
+0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
+0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
+0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
+0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
+0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
+0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
+0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
+0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
+0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
+0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
+0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
+0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+};
+
+#define updcrc32(b, c) (cr3tab[((int)c ^ b) & 0xff] ^ ((c >> 8) & 0x00FFFFFF))
+
+/* End of crc.c */
diff --git a/components/utilities/zmodem/rz.c b/components/utilities/zmodem/rz.c
index 23e952b23d..1324b5994b 100644
--- a/components/utilities/zmodem/rz.c
+++ b/components/utilities/zmodem/rz.c
@@ -1,401 +1,401 @@
/*
- * File : rz.c
- * the implemention of receiving files from the remote computers
+ * File : rz.c
+ * the implemention of receiving files from the remote computers
* through the zmodem protocol.
* Change Logs:
* Date Author Notes
* 2011-03-29 itspy
* 2011-12-12 aozima fixed syntax error.
- */
-
-#include <rtthread.h>
-#include <finsh.h>
-#include <shell.h>
-#include <rtdef.h>
-#include <dfs.h>
-#include <dfs_file.h>
-#include <dfs_posix.h>
-#include <stdio.h>
-#include "zdef.h"
-
-
-void zr_start(char *path);
-static rt_err_t zrec_init(rt_uint8_t *rxbuf, struct zfile *zf);
-static rt_err_t zrec_files(struct zfile *zf);
-static rt_err_t zwrite_file(rt_uint8_t *buf, rt_uint16_t size, struct zfile *zf);
-static rt_err_t zrec_file_data(rt_uint8_t *buf, struct zfile *zf);;
-static rt_err_t zrec_file(rt_uint8_t *rxbuf, struct zfile *zf);
-static rt_err_t zget_file_info(char *name, struct zfile *zf);
-static rt_err_t zwrite_file(rt_uint8_t *buf, rt_uint16_t size, struct zfile *zf);
-static void zrec_ack_bibi(void);
-
-
-/* start zmodem receive proccess */
-void zr_start(char *path)
-{
- struct zfile *zf;
- rt_uint8_t n;
- char ch,*p,*q;
- rt_err_t res = -RT_ERROR;
-
- zf = rt_malloc(sizeof(struct zfile));
- if (zf == RT_NULL)
- {
- rt_kprintf("zf: out of memory\r\n");
- return;
- }
- memset(zf, 0, sizeof(struct zfile));
- zf->fname = path;
- zf->fd = -1;
- res = zrec_files(zf);
- p = zf->fname;
- for (;;)
- {
- q = strstr(p,"/");
- if (q == RT_NULL) break;
- p = q+1;
- }
- if (res == RT_EOK)
- {
- rt_kprintf("\b\b\bfile: %s \r\n",p);
- rt_kprintf("size: %ld bytes\r\n",zf->bytes_received);
- rt_kprintf("receive completed.\r\n");
- close(zf->fd);
- rt_free(zf->fname);
- }
- else
- {
- rt_kprintf("\b\b\bfile: %s \r\n",p);
- rt_kprintf("size: 0 bytes\r\n");
- rt_kprintf("receive failed.\r\n");
- if (zf->fd >= 0)
- {
- close(zf->fd);
- unlink(zf->fname); /* remove this file */
- rt_free(zf->fname);
- }
- }
- rt_free(zf);
- /* waiting,clear console buffer */
- rt_thread_delay(RT_TICK_PER_SECOND/2);
- while(1)
- {
- n=rt_device_read(shell->device, 0, &ch, 1);
- if (n == 0) break;
- }
-
- return ;
-}
-
-/* receiver init, wait for ack */
-static rt_err_t zrec_init(rt_uint8_t *rxbuf, struct zfile *zf)
-{
- rt_uint8_t err_cnt = 0;
- rt_err_t res = -RT_ERROR;
-
- for (;;)
- {
- zput_pos(0L);
- tx_header[ZF0] = ZF0_CMD;
- tx_header[ZF1] = ZF1_CMD;
- tx_header[ZF2] = ZF2_CMD;
- zsend_hex_header(ZRINIT, tx_header);
-again:
- res = zget_header(rx_header);
- switch(res)
- {
- case ZFILE:
- ZF0_CMD = rx_header[ZF0];
- ZF1_CMD = rx_header[ZF1];
- ZF2_CMD = rx_header[ZF2];
- ZF3_CMD = rx_header[ZF3];
- res = zget_data(rxbuf, RX_BUFFER_SIZE);
- if (res == GOTCRCW)
- {
- if ((res =zget_file_info((char*)rxbuf,zf))!= RT_EOK)
- {
- zsend_hex_header(ZSKIP, tx_header);
- return (res);
- }
- return RT_EOK;;
- }
- zsend_hex_header(ZNAK, tx_header);
- goto again;
- case ZSINIT:
- if (zget_data((rt_uint8_t*)Attn, ZATTNLEN) == GOTCRCW) /* send zack */
- {
- zsend_hex_header(ZACK, tx_header);
- goto again;
- }
- zsend_hex_header(ZNAK, tx_header); /* send znak */
- goto again;
- case ZRQINIT:
- continue;
- case ZEOF:
- continue;
- case ZCOMPL:
- goto again;
- case ZFIN: /* end file session */
- zrec_ack_bibi();
- return res;
- default:
- if (++err_cnt >1000) return -RT_ERROR;
- continue;
- }
- }
-}
-
-/* receive files */
-static rt_err_t zrec_files(struct zfile *zf)
-{
- rt_uint8_t *rxbuf;
- rt_err_t res = -RT_ERROR;
-
- zinit_parameter();
- rxbuf = rt_malloc(RX_BUFFER_SIZE*sizeof(rt_uint8_t));
- if (rxbuf == RT_NULL)
- {
- rt_kprintf("rxbuf: out of memory\r\n");
- return -RT_ERROR;
- }
- rt_kprintf("\r\nrz: ready...\r\n"); /* here ready to receive things */
- if ((res = zrec_init(rxbuf,zf))!= RT_EOK)
- {
- rt_kprintf("\b\b\breceive init failed\r\n");
- rt_free(rxbuf);
- return -RT_ERROR;
- }
- res = zrec_file(rxbuf,zf);
- if (res == ZFIN)
- {
- rt_free(rxbuf);
- return RT_EOK; /* if finish session */
- }
- else if (res == ZCAN)
- {
- rt_free(rxbuf);
- return ZCAN; /* cancel by sender */
- }
- else
- {
- zsend_can();
- rt_free(rxbuf);
- return res;
- }
-}
-/* receive file */
-static rt_err_t zrec_file(rt_uint8_t *rxbuf, struct zfile *zf)
-{
- rt_err_t res = - RT_ERROR;
- rt_uint16_t err_cnt = 0;
-
- do
- {
- zput_pos(zf->bytes_received);
- zsend_hex_header(ZRPOS, tx_header);
-again:
- res = zget_header(rx_header);
- switch (res)
- {
- case ZDATA:
- zget_pos(Rxpos);
- if (Rxpos != zf->bytes_received)
- {
- zsend_break(Attn);
- continue;
- }
- err_cnt = 0;
- res = zrec_file_data(rxbuf,zf);
- if (res == -RT_ERROR)
- {
- zsend_break(Attn);
- continue;
- }
- else if (res == GOTCAN) return res;
- else goto again;
- case ZRPOS:
- zget_pos(Rxpos);
- continue;
- case ZEOF:
- err_cnt = 0;
- zget_pos(Rxpos);
- if (Rxpos != zf->bytes_received || Rxpos != zf->bytes_total)
- {
- continue;
- }
- return (zrec_init(rxbuf,zf)); /* resend ZRINIT packet,ready to receive next file */
- case ZFIN:
- zrec_ack_bibi();
- return ZCOMPL;
- case ZCAN:
-#ifdef ZDEBUG
- rt_kprintf("error code: sender cancelled \r\n");
-#endif
- zf->bytes_received = 0L; /* throw the received data */
- return res;
- case ZSKIP:
- return res;
- case -RT_ERROR:
- zsend_break(Attn);
- continue;
- case ZNAK:
- case TIMEOUT:
- default:
- continue;
- }
- } while(++err_cnt < 100);
-
- return res;
-}
-
-/* proccess file infomation */
-static rt_err_t zget_file_info(char *name, struct zfile *zf)
-{
- char *p;
- char *full_path,*ptr;
- rt_uint16_t i,len;
- rt_err_t res = -RT_ERROR;
- struct statfs buf;
- struct stat finfo;
-
- if (zf->fname == RT_NULL) /* extract file path */
- {
- len = strlen(name)+2;
- }
- else
- len = strlen(zf->fname)+strlen(name)+2;
- full_path = rt_malloc(len);
- if (full_path == RT_NULL)
- {
- zsend_can();
- rt_kprintf("\b\b\bfull_path: out of memory\n");
- rt_free(full_path);
- return -RT_ERROR;
- }
- memset(full_path,0,len);
-
- for (i=0,ptr=zf->fname;i<len-strlen(name)-2;i++)
- full_path[i] = *ptr++;
- full_path[len-strlen(name)-2] = '/';
- /* check if is a directory */
- if ((zf->fd=open(full_path, DFS_O_DIRECTORY,0)) < 0)
- {
- zsend_can();
- rt_kprintf("\b\b\bcan not open file:%s\r\n",zf->fname+1);
- close(zf->fd);
- zf->fd = -1;
- rt_free(full_path);
- return res;
- }
- fstat(zf->fd, &finfo);
- if ((finfo.st_mode&S_IFDIR) != S_IFDIR)
- {
- close(zf->fd);
- zf->fd = -1;
- return res;
- }
- close(zf->fd);
- /* get fullpath && file attributes */
- strcat(full_path,name);
- zf->fname = full_path;
- p = strlen(name)+name+1;
- sscanf((const char *)p, "%ld%lo%o", &zf->bytes_total,&zf->ctime,&zf->mode);
-#if defined(RT_USING_DFS) && defined(DFS_USING_WORKDIR)
- dfs_statfs(working_directory,&buf);
- if (zf->bytes_total > (buf.f_blocks * buf.f_bfree))
- {
- zsend_can();
- rt_kprintf("\b\b\bnot enough disk space\r\n");
- zf->fd = -1;
- rt_free(full_path);
- return -RT_ERROR;
- }
-#else
- buf = buf;
-#endif
- zf->bytes_received = 0L;
- if ((zf->fd = open(zf->fname,DFS_O_CREAT|DFS_O_WRONLY,0)) < 0) /* create or replace exist file */
- {
- zsend_can();
- rt_kprintf("\b\b\bcan not create file:%s \r\n",zf->fname);
- return -RT_ERROR;
- }
-
- return RT_EOK;
-}
-
-/* receive file data,continously, no ack */
-static rt_err_t zrec_file_data(rt_uint8_t *buf, struct zfile *zf)
-{
- rt_err_t res = -RT_ERROR;
-
-more_data:
- res = zget_data(buf,RX_BUFFER_SIZE);
- switch(res)
- {
- case GOTCRCW: /* zack received */
- zwrite_file(buf,Rxcount,zf);
- zf->bytes_received += Rxcount;
- zput_pos(zf->bytes_received);
- zsend_line(XON);
- zsend_hex_header(ZACK, tx_header);
- return RT_EOK;
- case GOTCRCQ:
- zwrite_file(buf,Rxcount,zf);
- zf->bytes_received += Rxcount;
- zput_pos(zf->bytes_received);
- zsend_hex_header(ZACK, tx_header);
- goto more_data;
- case GOTCRCG:
- zwrite_file(buf,Rxcount,zf);
- zf->bytes_received += Rxcount;
- goto more_data;
- case GOTCRCE:
- zwrite_file(buf,Rxcount,zf);
- zf->bytes_received += Rxcount;
- return RT_EOK;
- case GOTCAN:
-#ifdef ZDEBUG
- rt_kprintf("error code : ZCAN \r\n");
-#endif
- return res;
- case TIMEOUT:
- return res;
- case -RT_ERROR:
- zsend_break(Attn);
- return res;
- default:
- return res;
- }
-}
-
-/* write file */
-static rt_err_t zwrite_file(rt_uint8_t *buf,rt_uint16_t size, struct zfile *zf)
-{
- return (write(zf->fd,buf,size));
-}
-
-/* ack bibi */
-static void zrec_ack_bibi(void)
-{
- rt_uint8_t i;
-
- zput_pos(0L);
- for (i=0;i<3;i++)
- {
- zsend_hex_header(ZFIN, tx_header);
- switch (zread_line(100))
- {
- case 'O':
- zread_line(1);
- return;
- case RCDO:
- return;
- case TIMEOUT:
- default:
- break;
- }
- }
-}
-
-/* end of rz.c */
+ */
+
+#include <rtthread.h>
+#include <finsh.h>
+#include <shell.h>
+#include <rtdef.h>
+#include <dfs.h>
+#include <dfs_file.h>
+#include <dfs_posix.h>
+#include <stdio.h>
+#include "zdef.h"
+
+
+void zr_start(char *path);
+static rt_err_t zrec_init(rt_uint8_t *rxbuf, struct zfile *zf);
+static rt_err_t zrec_files(struct zfile *zf);
+static rt_err_t zwrite_file(rt_uint8_t *buf, rt_uint16_t size, struct zfile *zf);
+static rt_err_t zrec_file_data(rt_uint8_t *buf, struct zfile *zf);;
+static rt_err_t zrec_file(rt_uint8_t *rxbuf, struct zfile *zf);
+static rt_err_t zget_file_info(char *name, struct zfile *zf);
+static rt_err_t zwrite_file(rt_uint8_t *buf, rt_uint16_t size, struct zfile *zf);
+static void zrec_ack_bibi(void);
+
+
+/* start zmodem receive proccess */
+void zr_start(char *path)
+{
+ struct zfile *zf;
+ rt_uint8_t n;
+ char ch,*p,*q;
+ rt_err_t res = -RT_ERROR;
+
+ zf = rt_malloc(sizeof(struct zfile));
+ if (zf == RT_NULL)
+ {
+ rt_kprintf("zf: out of memory\r\n");
+ return;
+ }
+ memset(zf, 0, sizeof(struct zfile));
+ zf->fname = path;
+ zf->fd = -1;
+ res = zrec_files(zf);
+ p = zf->fname;
+ for (;;)
+ {
+ q = strstr(p,"/");
+ if (q == RT_NULL) break;
+ p = q+1;
+ }
+ if (res == RT_EOK)
+ {
+ rt_kprintf("\b\b\bfile: %s \r\n",p);
+ rt_kprintf("size: %ld bytes\r\n",zf->bytes_received);
+ rt_kprintf("receive completed.\r\n");
+ close(zf->fd);
+ rt_free(zf->fname);
+ }
+ else
+ {
+ rt_kprintf("\b\b\bfile: %s \r\n",p);
+ rt_kprintf("size: 0 bytes\r\n");
+ rt_kprintf("receive failed.\r\n");
+ if (zf->fd >= 0)
+ {
+ close(zf->fd);
+ unlink(zf->fname); /* remove this file */
+ rt_free(zf->fname);
+ }
+ }
+ rt_free(zf);
+ /* waiting,clear console buffer */
+ rt_thread_delay(RT_TICK_PER_SECOND/2);
+ while(1)
+ {
+ n=rt_device_read(shell->device, 0, &ch, 1);
+ if (n == 0) break;
+ }
+
+ return ;
+}
+
+/* receiver init, wait for ack */
+static rt_err_t zrec_init(rt_uint8_t *rxbuf, struct zfile *zf)
+{
+ rt_uint8_t err_cnt = 0;
+ rt_err_t res = -RT_ERROR;
+
+ for (;;)
+ {
+ zput_pos(0L);
+ tx_header[ZF0] = ZF0_CMD;
+ tx_header[ZF1] = ZF1_CMD;
+ tx_header[ZF2] = ZF2_CMD;
+ zsend_hex_header(ZRINIT, tx_header);
+again:
+ res = zget_header(rx_header);
+ switch(res)
+ {
+ case ZFILE:
+ ZF0_CMD = rx_header[ZF0];
+ ZF1_CMD = rx_header[ZF1];
+ ZF2_CMD = rx_header[ZF2];
+ ZF3_CMD = rx_header[ZF3];
+ res = zget_data(rxbuf, RX_BUFFER_SIZE);
+ if (res == GOTCRCW)
+ {
+ if ((res =zget_file_info((char*)rxbuf,zf))!= RT_EOK)
+ {
+ zsend_hex_header(ZSKIP, tx_header);
+ return (res);
+ }
+ return RT_EOK;;
+ }
+ zsend_hex_header(ZNAK, tx_header);
+ goto again;
+ case ZSINIT:
+ if (zget_data((rt_uint8_t*)Attn, ZATTNLEN) == GOTCRCW) /* send zack */
+ {
+ zsend_hex_header(ZACK, tx_header);
+ goto again;
+ }
+ zsend_hex_header(ZNAK, tx_header); /* send znak */
+ goto again;
+ case ZRQINIT:
+ continue;
+ case ZEOF:
+ continue;
+ case ZCOMPL:
+ goto again;
+ case ZFIN: /* end file session */
+ zrec_ack_bibi();
+ return res;
+ default:
+ if (++err_cnt >1000) return -RT_ERROR;
+ continue;
+ }
+ }
+}
+
+/* receive files */
+static rt_err_t zrec_files(struct zfile *zf)
+{
+ rt_uint8_t *rxbuf;
+ rt_err_t res = -RT_ERROR;
+
+ zinit_parameter();
+ rxbuf = rt_malloc(RX_BUFFER_SIZE*sizeof(rt_uint8_t));
+ if (rxbuf == RT_NULL)
+ {
+ rt_kprintf("rxbuf: out of memory\r\n");
+ return -RT_ERROR;
+ }
+ rt_kprintf("\r\nrz: ready...\r\n"); /* here ready to receive things */
+ if ((res = zrec_init(rxbuf,zf))!= RT_EOK)
+ {
+ rt_kprintf("\b\b\breceive init failed\r\n");
+ rt_free(rxbuf);
+ return -RT_ERROR;
+ }
+ res = zrec_file(rxbuf,zf);
+ if (res == ZFIN)
+ {
+ rt_free(rxbuf);
+ return RT_EOK; /* if finish session */
+ }
+ else if (res == ZCAN)
+ {
+ rt_free(rxbuf);
+ return ZCAN; /* cancel by sender */
+ }
+ else
+ {
+ zsend_can();
+ rt_free(rxbuf);
+ return res;
+ }
+}
+/* receive file */
+static rt_err_t zrec_file(rt_uint8_t *rxbuf, struct zfile *zf)
+{
+ rt_err_t res = - RT_ERROR;
+ rt_uint16_t err_cnt = 0;
+
+ do
+ {
+ zput_pos(zf->bytes_received);
+ zsend_hex_header(ZRPOS, tx_header);
+again:
+ res = zget_header(rx_header);
+ switch (res)
+ {
+ case ZDATA:
+ zget_pos(Rxpos);
+ if (Rxpos != zf->bytes_received)
+ {
+ zsend_break(Attn);
+ continue;
+ }
+ err_cnt = 0;
+ res = zrec_file_data(rxbuf,zf);
+ if (res == -RT_ERROR)
+ {
+ zsend_break(Attn);
+ continue;
+ }
+ else if (res == GOTCAN) return res;
+ else goto again;
+ case ZRPOS:
+ zget_pos(Rxpos);
+ continue;
+ case ZEOF:
+ err_cnt = 0;
+ zget_pos(Rxpos);
+ if (Rxpos != zf->bytes_received || Rxpos != zf->bytes_total)
+ {
+ continue;
+ }
+ return (zrec_init(rxbuf,zf)); /* resend ZRINIT packet,ready to receive next file */
+ case ZFIN:
+ zrec_ack_bibi();
+ return ZCOMPL;
+ case ZCAN:
+#ifdef ZDEBUG
+ rt_kprintf("error code: sender cancelled \r\n");
+#endif
+ zf->bytes_received = 0L; /* throw the received data */
+ return res;
+ case ZSKIP:
+ return res;
+ case -RT_ERROR:
+ zsend_break(Attn);
+ continue;
+ case ZNAK:
+ case TIMEOUT:
+ default:
+ continue;
+ }
+ } while(++err_cnt < 100);
+
+ return res;
+}
+
+/* proccess file infomation */
+static rt_err_t zget_file_info(char *name, struct zfile *zf)
+{
+ char *p;
+ char *full_path,*ptr;
+ rt_uint16_t i,len;
+ rt_err_t res = -RT_ERROR;
+ struct statfs buf;
+ struct stat finfo;
+
+ if (zf->fname == RT_NULL) /* extract file path */
+ {
+ len = strlen(name)+2;
+ }
+ else
+ len = strlen(zf->fname)+strlen(name)+2;
+ full_path = rt_malloc(len);
+ if (full_path == RT_NULL)
+ {
+ zsend_can();
+ rt_kprintf("\b\b\bfull_path: out of memory\n");
+ rt_free(full_path);
+ return -RT_ERROR;
+ }
+ memset(full_path,0,len);
+
+ for (i=0,ptr=zf->fname;i<len-strlen(name)-2;i++)
+ full_path[i] = *ptr++;
+ full_path[len-strlen(name)-2] = '/';
+ /* check if is a directory */
+ if ((zf->fd=open(full_path, DFS_O_DIRECTORY,0)) < 0)
+ {
+ zsend_can();
+ rt_kprintf("\b\b\bcan not open file:%s\r\n",zf->fname+1);
+ close(zf->fd);
+ zf->fd = -1;
+ rt_free(full_path);
+ return res;
+ }
+ fstat(zf->fd, &finfo);
+ if ((finfo.st_mode&S_IFDIR) != S_IFDIR)
+ {
+ close(zf->fd);
+ zf->fd = -1;
+ return res;
+ }
+ close(zf->fd);
+ /* get fullpath && file attributes */
+ strcat(full_path,name);
+ zf->fname = full_path;
+ p = strlen(name)+name+1;
+ sscanf((const char *)p, "%ld%lo%o", &zf->bytes_total,&zf->ctime,&zf->mode);
+#if defined(RT_USING_DFS) && defined(DFS_USING_WORKDIR)
+ dfs_statfs(working_directory,&buf);
+ if (zf->bytes_total > (buf.f_blocks * buf.f_bfree))
+ {
+ zsend_can();
+ rt_kprintf("\b\b\bnot enough disk space\r\n");
+ zf->fd = -1;
+ rt_free(full_path);
+ return -RT_ERROR;
+ }
+#else
+ buf = buf;
+#endif
+ zf->bytes_received = 0L;
+ if ((zf->fd = open(zf->fname,DFS_O_CREAT|DFS_O_WRONLY,0)) < 0) /* create or replace exist file */
+ {
+ zsend_can();
+ rt_kprintf("\b\b\bcan not create file:%s \r\n",zf->fname);
+ return -RT_ERROR;
+ }
+
+ return RT_EOK;
+}
+
+/* receive file data,continously, no ack */
+static rt_err_t zrec_file_data(rt_uint8_t *buf, struct zfile *zf)
+{
+ rt_err_t res = -RT_ERROR;
+
+more_data:
+ res = zget_data(buf,RX_BUFFER_SIZE);
+ switch(res)
+ {
+ case GOTCRCW: /* zack received */
+ zwrite_file(buf,Rxcount,zf);
+ zf->bytes_received += Rxcount;
+ zput_pos(zf->bytes_received);
+ zsend_line(XON);
+ zsend_hex_header(ZACK, tx_header);
+ return RT_EOK;
+ case GOTCRCQ:
+ zwrite_file(buf,Rxcount,zf);
+ zf->bytes_received += Rxcount;
+ zput_pos(zf->bytes_received);
+ zsend_hex_header(ZACK, tx_header);
+ goto more_data;
+ case GOTCRCG:
+ zwrite_file(buf,Rxcount,zf);
+ zf->bytes_received += Rxcount;
+ goto more_data;
+ case GOTCRCE:
+ zwrite_file(buf,Rxcount,zf);
+ zf->bytes_received += Rxcount;
+ return RT_EOK;
+ case GOTCAN:
+#ifdef ZDEBUG
+ rt_kprintf("error code : ZCAN \r\n");
+#endif
+ return res;
+ case TIMEOUT:
+ return res;
+ case -RT_ERROR:
+ zsend_break(Attn);
+ return res;
+ default:
+ return res;
+ }
+}
+
+/* write file */
+static rt_err_t zwrite_file(rt_uint8_t *buf,rt_uint16_t size, struct zfile *zf)
+{
+ return (write(zf->fd,buf,size));
+}
+
+/* ack bibi */
+static void zrec_ack_bibi(void)
+{
+ rt_uint8_t i;
+
+ zput_pos(0L);
+ for (i=0;i<3;i++)
+ {
+ zsend_hex_header(ZFIN, tx_header);
+ switch (zread_line(100))
+ {
+ case 'O':
+ zread_line(1);
+ return;
+ case RCDO:
+ return;
+ case TIMEOUT:
+ default:
+ break;
+ }
+ }
+}
+
+/* end of rz.c */
diff --git a/components/utilities/zmodem/sz.c b/components/utilities/zmodem/sz.c
index ad30c97361..0fde4165f6 100644
--- a/components/utilities/zmodem/sz.c
+++ b/components/utilities/zmodem/sz.c
@@ -1,321 +1,321 @@
/*
- * File : sz.c
- * the implemention of sending files to the remote computers
+ * File : sz.c
+ * the implemention of sending files to the remote computers
* through the zmodem protocol.
* Change Logs:
* Date Author Notes
* 2011-03-29 itspy
- */
-
-#include <rtthread.h>
-#include <finsh.h>
-#include <shell.h>
-#include <rtdef.h>
-#include <dfs.h>
-#include <dfs_file.h>
-#include <dfs_posix.h>
-#include "zdef.h"
-
-
-static rt_uint8_t TX_BUFFER[TX_BUFFER_SIZE]; /* sender buffer */
-static rt_uint8_t file_cnt = 0; /* count of number of files opened */
-static rt_uint8_t Rxflags = 0; /* rx parameter flags */
-static rt_uint8_t ZF2_OP; /* file transfer option */
-
-void zs_start(char *path);
-static void zsend_init(void);
-static rt_err_t zsend_files(struct zfile *zf);
-static rt_err_t zsend_file(struct zfile *zf, rt_uint8_t *buf, rt_uint16_t len);
-static rt_err_t zsend_file_data(struct zfile *zf);
-static rt_uint16_t zfill_buffer(struct zfile *zf, rt_uint8_t *buf, rt_uint16_t size);
-static rt_err_t zget_sync(void);
-static void zsay_bibi(void);
-
-
-
-
-/* start zmodem send process */
-void zs_start(char *path)
-{
- struct zfile *zf;
- rt_err_t res = RT_ERROR;
- char *p,*q;
- zf = rt_malloc(sizeof(struct zfile));
- if (zf == RT_NULL)
- {
- rt_kprintf("zf: out of memory\r\n");
- return;
- }
- rt_kprintf("\r\nsz: ready...\r\n"); /* here ready to send things */
- memset(zf, 0, sizeof(struct zfile));
- zf->fname = path;
- zf->fd = -1;
- res = zsend_files(zf);
- p = zf->fname;
- for (;;)
- {
- q = strstr(p,"/");
- if (q == RT_NULL) break;
- p = q+1;
- }
- if (res == RT_EOK)
- {
- rt_kprintf("\r\nfile: %s \r\nsize: %ld bytes\r\nsend completed.\r\n",
- p,zf->bytes_received);
- }
- else
- {
- rt_kprintf("\r\nfile: %s \r\nsize: 0 bytes\r\nsend failed.\r\n",p);
- }
- rt_free(zf);
-
- return;
-}
-
-/* init the parameters */
-static void zsend_init(void)
-{
- rt_err_t res = -RT_ERROR;
-
- zinit_parameter();
- for(;;) /* wait ZPAD */
- {
- res = zread_line(800);
- if (res == ZPAD) break;
- }
- for (;;)
- {
- res = zget_header(rx_header);
- if (res == ZRINIT) break;
- }
- if ((rx_header[ZF1] & ZRQNVH))
- {
- zput_pos(0x80L); /* Show we can var header */
- zsend_hex_header(ZRQINIT, tx_header);
- }
- Rxflags = rx_header[ZF0] & 0377;
- if (Rxflags & CANFC32) Txfcs32 = 1; /* used 32bits CRC check */
-
- if (ZF2_OP == ZTRLE && (Rxflags & CANRLE)) /* for RLE packet */
- Txfcs32 = 2;
- else
- ZF2_OP = 0;
- /* send SINIT cmd */
- return;
-}
-
-/* send files */
-static rt_err_t zsend_files(struct zfile *zf)
-{
- char *p,*q;
- char *str = "/";
- struct stat finfo;
- rt_err_t res = -RT_ERROR;
-
- if (zf->fname == RT_NULL)
- {
- rt_kprintf("\r\nerror: no file to be send.\r\n");
- return res;
- }
- if ((zf->fd=open(zf->fname, DFS_O_RDONLY,0)) <0)
- {
- rt_kprintf("\r\ncan not open file:%s\r\n",zf->fname+1);
- return res;
- }
-
- zf->file_end = 0;
- ++file_cnt;
- /* extract file name */
- p = zf->fname;
- for (;;)
- {
- q = strstr(p,str);
- if (q == RT_NULL) break;
- p = q+1;
- }
- q = (char*)TX_BUFFER;
- for (;;)
- {
- *q++ = *p++;
- if (*p == 0) break;
- }
- *q++ = 0;
- p=q;
- while (q < (char*)(TX_BUFFER + 1024))
- *q++ = 0;
- /* get file attributes */
- fstat(zf->fd,&finfo);
- Left_sizes += finfo.st_size;
- rt_sprintf(p, "%lu %lo %o 3 %d %ld", (long)finfo.st_size, finfo.st_mtime,
- finfo.st_mode, file_cnt, Left_sizes);
- Left_sizes -= finfo.st_size;
- TX_BUFFER[127] = (finfo.st_size + 127) >>7;
- TX_BUFFER[126] = (finfo.st_size + 127) >>15;
-
- zsend_init();
- /* start sending files */
- res = zsend_file(zf,TX_BUFFER, (p-(char*)TX_BUFFER)+strlen(p)+1);
- zsay_bibi();
- close(zf->fd);
-
- return res;
-}
-
-/* send file name and related info */
-static rt_err_t zsend_file(struct zfile *zf, rt_uint8_t *buf, rt_uint16_t len)
-{
- rt_uint8_t cnt;
- rt_err_t res = -RT_ERROR;
-
- for (cnt=0;cnt<5;cnt++)
- {
- tx_header[ZF0] = ZF0_CMD; /* file conversion option */
- tx_header[ZF1] = ZF1_CMD; /* file management option */
- tx_header[ZF2] = (ZF3_CMD|ZF2_OP); /* file transfer option */
- tx_header[ZF3] = ZF3_CMD;
- zsend_bin_header(ZFILE, tx_header);
- zsend_bin_data(buf, len, ZCRCW);
-loop:
- res = zget_header(rx_header);
- switch (res)
- {
- case ZRINIT:
- while ((res = zread_line(50)) > 0)
- {
- if (res == ZPAD)
- {
- goto loop;
- }
- }
- break;
- case ZCAN:
- case TIMEOUT:
- case ZABORT:
- case ZFIN:
- break;
- case -RT_ERROR:
- case ZNAK:
- break;
- case ZCRC: /* no CRC request */
- goto loop;
- case ZFERR:
- case ZSKIP:
- break;
- case ZRPOS: /* here we want */
- zget_pos(Rxpos);
- Txpos = Rxpos;
- return(zsend_file_data(zf));
- default:
- break;
- }
- }
-
- return res;
-}
-
-/* send the file data */
-static rt_err_t zsend_file_data(struct zfile *zf)
-{
- rt_int16_t cnt;
- rt_uint8_t cmd;
- rt_err_t res = -RT_ERROR;
- /* send ZDATA packet, start to send data */
-start_send:
- zput_pos(Txpos);
- zsend_bin_header(ZDATA, tx_header);
- do
- {
- cnt = zfill_buffer(zf,TX_BUFFER,RX_BUFFER_SIZE);
- if (cnt < RX_BUFFER_SIZE )
- cmd = ZCRCE;
- else
- cmd = ZCRCG;
- zsend_bin_data(TX_BUFFER, cnt, cmd);
- zf->bytes_received= Txpos += cnt;
- if (cmd == ZCRCW)
- goto get_syn1;
- } while (cnt == RX_BUFFER_SIZE);
- for (;;) /* get ack and check if send finish */
- {
- zput_pos(Txpos);
- zsend_bin_header(ZEOF, tx_header);
-get_syn1:
- res = zget_sync();
- switch (res)
- {
- case ZACK:
- goto get_syn1;
- case ZNAK:
- continue;
- case ZRPOS: /* resend here */
- lseek(zf->fd,Txpos,0);
- goto start_send;
- case ZRINIT: /* send finish,then begin to send next file */
- return RT_EOK;
- case ZSKIP:
- case -RT_ERROR:
- return res;
- default:
- return res;
- }
- }
-}
-
-/* fill file data to buffer*/
-static rt_uint16_t zfill_buffer(struct zfile *zf, rt_uint8_t *buf, rt_uint16_t size)
-{
- return (read(zf->fd,buf,size));
-}
-
-/* wait sync(ack) from the receiver */
-static rt_err_t zget_sync(void)
-{
- rt_err_t res = -RT_ERROR;
-
- for (;;)
- {
- res = zget_header(rx_header);
- switch (res)
- {
- case ZCAN:
- case ZABORT:
- case ZFIN:
- case TIMEOUT:
- return -RT_ERROR;
- case ZRPOS: /* get pos, need to resend */
- zget_pos(Rxpos);
- Txpos = Rxpos;
- return res;
- case ZACK:
- return res;
- case ZRINIT: /* get ZRINIT indicate that the prev file send completed */
- return res;
- case ZSKIP:
- return res;
- case -RT_ERROR:
- default:
- zsend_bin_header(ZNAK, tx_header);
- continue;
- }
- }
-}
-
-/* say "bibi" to the receiver */
-static void zsay_bibi(void)
-{
- for (;;)
- {
- zput_pos(0L); /* reninit position of next file*/
- zsend_hex_header(ZFIN, tx_header); /* send finished session cmd */
- switch (zget_header(rx_header))
- {
- case ZFIN:
- zsend_line('O');
- zsend_line('O');
- case ZCAN:
- case TIMEOUT:
- return;
- }
- }
-}
-/* end of sz.c */
+ */
+
+#include <rtthread.h>
+#include <finsh.h>
+#include <shell.h>
+#include <rtdef.h>
+#include <dfs.h>
+#include <dfs_file.h>
+#include <dfs_posix.h>
+#include "zdef.h"
+
+
+static rt_uint8_t TX_BUFFER[TX_BUFFER_SIZE]; /* sender buffer */
+static rt_uint8_t file_cnt = 0; /* count of number of files opened */
+static rt_uint8_t Rxflags = 0; /* rx parameter flags */
+static rt_uint8_t ZF2_OP; /* file transfer option */
+
+void zs_start(char *path);
+static void zsend_init(void);
+static rt_err_t zsend_files(struct zfile *zf);
+static rt_err_t zsend_file(struct zfile *zf, rt_uint8_t *buf, rt_uint16_t len);
+static rt_err_t zsend_file_data(struct zfile *zf);
+static rt_uint16_t zfill_buffer(struct zfile *zf, rt_uint8_t *buf, rt_uint16_t size);
+static rt_err_t zget_sync(void);
+static void zsay_bibi(void);
+
+
+
+
+/* start zmodem send process */
+void zs_start(char *path)
+{
+ struct zfile *zf;
+ rt_err_t res = RT_ERROR;
+ char *p,*q;
+ zf = rt_malloc(sizeof(struct zfile));
+ if (zf == RT_NULL)
+ {
+ rt_kprintf("zf: out of memory\r\n");
+ return;
+ }
+ rt_kprintf("\r\nsz: ready...\r\n"); /* here ready to send things */
+ memset(zf, 0, sizeof(struct zfile));
+ zf->fname = path;
+ zf->fd = -1;
+ res = zsend_files(zf);
+ p = zf->fname;
+ for (;;)
+ {
+ q = strstr(p,"/");
+ if (q == RT_NULL) break;
+ p = q+1;
+ }
+ if (res == RT_EOK)
+ {
+ rt_kprintf("\r\nfile: %s \r\nsize: %ld bytes\r\nsend completed.\r\n",
+ p,zf->bytes_received);
+ }
+ else
+ {
+ rt_kprintf("\r\nfile: %s \r\nsize: 0 bytes\r\nsend failed.\r\n",p);
+ }
+ rt_free(zf);
+
+ return;
+}
+
+/* init the parameters */
+static void zsend_init(void)
+{
+ rt_err_t res = -RT_ERROR;
+
+ zinit_parameter();
+ for(;;) /* wait ZPAD */
+ {
+ res = zread_line(800);
+ if (res == ZPAD) break;
+ }
+ for (;;)
+ {
+ res = zget_header(rx_header);
+ if (res == ZRINIT) break;
+ }
+ if ((rx_header[ZF1] & ZRQNVH))
+ {
+ zput_pos(0x80L); /* Show we can var header */
+ zsend_hex_header(ZRQINIT, tx_header);
+ }
+ Rxflags = rx_header[ZF0] & 0377;
+ if (Rxflags & CANFC32) Txfcs32 = 1; /* used 32bits CRC check */
+
+ if (ZF2_OP == ZTRLE && (Rxflags & CANRLE)) /* for RLE packet */
+ Txfcs32 = 2;
+ else
+ ZF2_OP = 0;
+ /* send SINIT cmd */
+ return;
+}
+
+/* send files */
+static rt_err_t zsend_files(struct zfile *zf)
+{
+ char *p,*q;
+ char *str = "/";
+ struct stat finfo;
+ rt_err_t res = -RT_ERROR;
+
+ if (zf->fname == RT_NULL)
+ {
+ rt_kprintf("\r\nerror: no file to be send.\r\n");
+ return res;
+ }
+ if ((zf->fd=open(zf->fname, DFS_O_RDONLY,0)) <0)
+ {
+ rt_kprintf("\r\ncan not open file:%s\r\n",zf->fname+1);
+ return res;
+ }
+
+ zf->file_end = 0;
+ ++file_cnt;
+ /* extract file name */
+ p = zf->fname;
+ for (;;)
+ {
+ q = strstr(p,str);
+ if (q == RT_NULL) break;
+ p = q+1;
+ }
+ q = (char*)TX_BUFFER;
+ for (;;)
+ {
+ *q++ = *p++;
+ if (*p == 0) break;
+ }
+ *q++ = 0;
+ p=q;
+ while (q < (char*)(TX_BUFFER + 1024))
+ *q++ = 0;
+ /* get file attributes */
+ fstat(zf->fd,&finfo);
+ Left_sizes += finfo.st_size;
+ rt_sprintf(p, "%lu %lo %o 3 %d %ld", (long)finfo.st_size, finfo.st_mtime,
+ finfo.st_mode, file_cnt, Left_sizes);
+ Left_sizes -= finfo.st_size;
+ TX_BUFFER[127] = (finfo.st_size + 127) >>7;
+ TX_BUFFER[126] = (finfo.st_size + 127) >>15;
+
+ zsend_init();
+ /* start sending files */
+ res = zsend_file(zf,TX_BUFFER, (p-(char*)TX_BUFFER)+strlen(p)+1);
+ zsay_bibi();
+ close(zf->fd);
+
+ return res;
+}
+
+/* send file name and related info */
+static rt_err_t zsend_file(struct zfile *zf, rt_uint8_t *buf, rt_uint16_t len)
+{
+ rt_uint8_t cnt;
+ rt_err_t res = -RT_ERROR;
+
+ for (cnt=0;cnt<5;cnt++)
+ {
+ tx_header[ZF0] = ZF0_CMD; /* file conversion option */
+ tx_header[ZF1] = ZF1_CMD; /* file management option */
+ tx_header[ZF2] = (ZF3_CMD|ZF2_OP); /* file transfer option */
+ tx_header[ZF3] = ZF3_CMD;
+ zsend_bin_header(ZFILE, tx_header);
+ zsend_bin_data(buf, len, ZCRCW);
+loop:
+ res = zget_header(rx_header);
+ switch (res)
+ {
+ case ZRINIT:
+ while ((res = zread_line(50)) > 0)
+ {
+ if (res == ZPAD)
+ {
+ goto loop;
+ }
+ }
+ break;
+ case ZCAN:
+ case TIMEOUT:
+ case ZABORT:
+ case ZFIN:
+ break;
+ case -RT_ERROR:
+ case ZNAK:
+ break;
+ case ZCRC: /* no CRC request */
+ goto loop;
+ case ZFERR:
+ case ZSKIP:
+ break;
+ case ZRPOS: /* here we want */
+ zget_pos(Rxpos);
+ Txpos = Rxpos;
+ return(zsend_file_data(zf));
+ default:
+ break;
+ }
+ }
+
+ return res;
+}
+
+/* send the file data */
+static rt_err_t zsend_file_data(struct zfile *zf)
+{
+ rt_int16_t cnt;
+ rt_uint8_t cmd;
+ rt_err_t res = -RT_ERROR;
+ /* send ZDATA packet, start to send data */
+start_send:
+ zput_pos(Txpos);
+ zsend_bin_header(ZDATA, tx_header);
+ do
+ {
+ cnt = zfill_buffer(zf,TX_BUFFER,RX_BUFFER_SIZE);
+ if (cnt < RX_BUFFER_SIZE )
+ cmd = ZCRCE;
+ else
+ cmd = ZCRCG;
+ zsend_bin_data(TX_BUFFER, cnt, cmd);
+ zf->bytes_received= Txpos += cnt;
+ if (cmd == ZCRCW)
+ goto get_syn1;
+ } while (cnt == RX_BUFFER_SIZE);
+ for (;;) /* get ack and check if send finish */
+ {
+ zput_pos(Txpos);
+ zsend_bin_header(ZEOF, tx_header);
+get_syn1:
+ res = zget_sync();
+ switch (res)
+ {
+ case ZACK:
+ goto get_syn1;
+ case ZNAK:
+ continue;
+ case ZRPOS: /* resend here */
+ lseek(zf->fd,Txpos,0);
+ goto start_send;
+ case ZRINIT: /* send finish,then begin to send next file */
+ return RT_EOK;
+ case ZSKIP:
+ case -RT_ERROR:
+ return res;
+ default:
+ return res;
+ }
+ }
+}
+
+/* fill file data to buffer*/
+static rt_uint16_t zfill_buffer(struct zfile *zf, rt_uint8_t *buf, rt_uint16_t size)
+{
+ return (read(zf->fd,buf,size));
+}
+
+/* wait sync(ack) from the receiver */
+static rt_err_t zget_sync(void)
+{
+ rt_err_t res = -RT_ERROR;
+
+ for (;;)
+ {
+ res = zget_header(rx_header);
+ switch (res)
+ {
+ case ZCAN:
+ case ZABORT:
+ case ZFIN:
+ case TIMEOUT:
+ return -RT_ERROR;
+ case ZRPOS: /* get pos, need to resend */
+ zget_pos(Rxpos);
+ Txpos = Rxpos;
+ return res;
+ case ZACK:
+ return res;
+ case ZRINIT: /* get ZRINIT indicate that the prev file send completed */
+ return res;
+ case ZSKIP:
+ return res;
+ case -RT_ERROR:
+ default:
+ zsend_bin_header(ZNAK, tx_header);
+ continue;
+ }
+ }
+}
+
+/* say "bibi" to the receiver */
+static void zsay_bibi(void)
+{
+ for (;;)
+ {
+ zput_pos(0L); /* reninit position of next file*/
+ zsend_hex_header(ZFIN, tx_header); /* send finished session cmd */
+ switch (zget_header(rx_header))
+ {
+ case ZFIN:
+ zsend_line('O');
+ zsend_line('O');
+ case ZCAN:
+ case TIMEOUT:
+ return;
+ }
+ }
+}
+/* end of sz.c */
diff --git a/components/utilities/zmodem/zcore.c b/components/utilities/zmodem/zcore.c
index cd52e2b245..02ffbba830 100644
--- a/components/utilities/zmodem/zcore.c
+++ b/components/utilities/zmodem/zcore.c
@@ -1,27 +1,27 @@
/*
- * File : rz.c
+ * File : rz.c
* the core functions of implementing zmodem protocol
* Change Logs:
* Date Author Notes
* 2011-03-29 itspy
- */
-
-#include <rtthread.h>
-#include <finsh.h>
-#include <shell.h>
-#include <rtdef.h>
-#include <dfs.h>
-#include <dfs_file.h>
-#include <dfs_posix.h>
-#include <stdio.h>
-#include "zdef.h"
+ */
+
+#include <rtthread.h>
+#include <finsh.h>
+#include <shell.h>
+#include <rtdef.h>
+#include <dfs.h>
+#include <dfs_file.h>
+#include <dfs_posix.h>
+#include <stdio.h>
+#include "zdef.h"
char ZF0_CMD; /* file conversion request */
char ZF1_CMD; /* file management request */
-char ZF2_CMD; /* file transport request */
+char ZF2_CMD; /* file transport request */
char ZF3_CMD;
rt_uint8_t Rxframeind; /* ZBIN ZBIN32, or ZHEX type of frame */
-rt_uint16_t Rxcount; /* received count*/
+rt_uint16_t Rxcount; /* received count*/
char header_type; /* header type */
rt_uint8_t rx_header[4]; /* received header */
rt_uint8_t tx_header[4]; /* transmitted header */
@@ -29,116 +29,116 @@ rt_uint32_t Rxpos; /* received file position */
rt_uint32_t Txpos; /* transmitted file position */
rt_uint8_t Txfcs32; /* TURE means send binary frames with 32 bit FCS */
rt_uint8_t TxCRC; /* controls 32 bit CRC being sent */
-rt_uint8_t RxCRC; /* indicates/controls 32 bit CRC being received */
+rt_uint8_t RxCRC; /* indicates/controls 32 bit CRC being received */
/* 0 == CRC16, 1 == CRC32, 2 == CRC32 + RLE */
-char Attn[ZATTNLEN+1]; /* attention string rx sends to tx on err */
-
-void zinit_parameter(void);
-void zsend_bin_header(rt_uint8_t type, rt_uint8_t *hdr);
-void zsend_hex_header(rt_uint8_t type, rt_uint8_t *hdr);
-void zsend_bin_data(rt_uint8_t *buf, rt_int16_t len, rt_uint8_t frameend);
-static rt_int16_t zrec_data16(rt_uint8_t *buf, rt_uint16_t len);
-static rt_int16_t zrec_data32(rt_uint8_t *buf, rt_int16_t len);
-static rt_int16_t zrec_data32r(rt_uint8_t *buf, rt_int16_t len);
-rt_int16_t zget_data(rt_uint8_t *buf, rt_uint16_t len);
-rt_int16_t zget_header(rt_uint8_t *hdr);
-static rt_int16_t zget_bin_header(rt_uint8_t *hdr);
-static rt_int16_t zget_bin_fcs(rt_uint8_t *hdr);
-rt_int16_t zget_hex_header(rt_uint8_t *hdr);
-static void zsend_ascii(rt_uint8_t c);
-void zsend_zdle_char(rt_uint16_t ch);
-static rt_int16_t zget_hex(void);
-rt_int16_t zread_byte(void);
-rt_int16_t zxor_read(void);
-void zput_pos(rt_uint32_t pos);
-void zget_pos(rt_uint32_t pos);
-
+char Attn[ZATTNLEN+1]; /* attention string rx sends to tx on err */
+
+void zinit_parameter(void);
+void zsend_bin_header(rt_uint8_t type, rt_uint8_t *hdr);
+void zsend_hex_header(rt_uint8_t type, rt_uint8_t *hdr);
+void zsend_bin_data(rt_uint8_t *buf, rt_int16_t len, rt_uint8_t frameend);
+static rt_int16_t zrec_data16(rt_uint8_t *buf, rt_uint16_t len);
+static rt_int16_t zrec_data32(rt_uint8_t *buf, rt_int16_t len);
+static rt_int16_t zrec_data32r(rt_uint8_t *buf, rt_int16_t len);
+rt_int16_t zget_data(rt_uint8_t *buf, rt_uint16_t len);
+rt_int16_t zget_header(rt_uint8_t *hdr);
+static rt_int16_t zget_bin_header(rt_uint8_t *hdr);
+static rt_int16_t zget_bin_fcs(rt_uint8_t *hdr);
+rt_int16_t zget_hex_header(rt_uint8_t *hdr);
+static void zsend_ascii(rt_uint8_t c);
+void zsend_zdle_char(rt_uint16_t ch);
+static rt_int16_t zget_hex(void);
+rt_int16_t zread_byte(void);
+rt_int16_t zxor_read(void);
+void zput_pos(rt_uint32_t pos);
+void zget_pos(rt_uint32_t pos);
+
+
+
+
+void zinit_parameter(void)
+{
+ rt_uint8_t i;
+
+ ZF0_CMD = CANFC32|CANFDX|CANOVIO; /* not chose CANFC32,CANRLE,although it have been supported */
+ ZF1_CMD = 0; /* fix header length,not support CANVHDR */
+ ZF2_CMD = 0;
+ ZF3_CMD = 0;
+ Rxframeind =0;
+ header_type = 0;
+ Rxcount = 0;
+ for (i=0;i<4;i++) rx_header[i] = tx_header[i] = 0;
+ Rxpos = Txpos = 0;
+ RxCRC = 0;
+ Txfcs32 = 0;
+
+ return ;
+}
-
-
-void zinit_parameter(void)
-{
- rt_uint8_t i;
-
- ZF0_CMD = CANFC32|CANFDX|CANOVIO; /* not chose CANFC32,CANRLE,although it have been supported */
- ZF1_CMD = 0; /* fix header length,not support CANVHDR */
- ZF2_CMD = 0;
- ZF3_CMD = 0;
- Rxframeind =0;
- header_type = 0;
- Rxcount = 0;
- for (i=0;i<4;i++) rx_header[i] = tx_header[i] = 0;
- Rxpos = Txpos = 0;
- RxCRC = 0;
- Txfcs32 = 0;
-
- return ;
-}
-
/* send binary header */
void zsend_bin_header(rt_uint8_t type, rt_uint8_t *hdr)
{
rt_uint8_t i;
- rt_uint32_t crc;
+ rt_uint32_t crc;
- zsend_byte(ZPAD);
+ zsend_byte(ZPAD);
zsend_byte(ZDLE);
- TxCRC = Txfcs32;
- if (TxCRC == 0)
+ TxCRC = Txfcs32;
+ if (TxCRC == 0)
{
- zsend_byte(ZBIN);
- zsend_zdle_char(type);
- /* add 16bits crc */
- crc = 0L;
- crc = updcrc16(type, 0);
- for (i=0;i<4;i++)
- {
- zsend_zdle_char(*hdr);
- crc = updcrc16((0377 & *hdr++),crc);
- }
+ zsend_byte(ZBIN);
+ zsend_zdle_char(type);
+ /* add 16bits crc */
+ crc = 0L;
+ crc = updcrc16(type, 0);
+ for (i=0;i<4;i++)
+ {
+ zsend_zdle_char(*hdr);
+ crc = updcrc16((0377 & *hdr++),crc);
+ }
crc = updcrc16(0,updcrc16(0,crc));
zsend_zdle_char(((int)(crc>>8)));
- zsend_zdle_char(crc);
- }
- else if(TxCRC == 1)
- {
- zsend_byte(ZBIN32);
- zsend_zdle_char(type);
- /* add 32bits crc */
- crc = 0xffffffffL;
- crc = updcrc32(type, crc);
- for (i=0;i<4;i++)
- {
- zsend_zdle_char(*hdr);
- crc = updcrc32((0377 & *hdr++), crc);
- }
+ zsend_zdle_char(crc);
+ }
+ else if(TxCRC == 1)
+ {
+ zsend_byte(ZBIN32);
+ zsend_zdle_char(type);
+ /* add 32bits crc */
+ crc = 0xffffffffL;
+ crc = updcrc32(type, crc);
+ for (i=0;i<4;i++)
+ {
+ zsend_zdle_char(*hdr);
+ crc = updcrc32((0377 & *hdr++), crc);
+ }
crc = ~crc;
- for (i=0; i<4;i++)
+ for (i=0; i<4;i++)
{
zsend_zdle_char(crc);
crc >>= 8;
- }
- }
- else if (TxCRC == 2)
- {
- zsend_byte(ZBINR32);
- zsend_zdle_char(type);
- /* add 32bits crc */
- crc = 0xffffffffL;
- crc = updcrc32(type, crc);
- for (i=0;i<4;i++)
- {
- zsend_zdle_char(*hdr);
- crc = updcrc32((0377 & *hdr++), crc);
- }
+ }
+ }
+ else if (TxCRC == 2)
+ {
+ zsend_byte(ZBINR32);
+ zsend_zdle_char(type);
+ /* add 32bits crc */
+ crc = 0xffffffffL;
+ crc = updcrc32(type, crc);
+ for (i=0;i<4;i++)
+ {
+ zsend_zdle_char(*hdr);
+ crc = updcrc32((0377 & *hdr++), crc);
+ }
crc = ~crc;
- for (i=0; i<4;i++)
+ for (i=0; i<4;i++)
{
zsend_zdle_char(crc);
crc >>= 8;
- }
- }
-
+ }
+ }
+
return;
}
@@ -146,53 +146,53 @@ void zsend_bin_header(rt_uint8_t type, rt_uint8_t *hdr)
void zsend_hex_header(rt_uint8_t type, rt_uint8_t *hdr)
{
rt_uint8_t i;
- rt_uint16_t crc;
+ rt_uint16_t crc;
zsend_line(ZPAD); zsend_line(ZPAD); zsend_line(ZDLE);
zsend_line(ZHEX);
zsend_ascii(type);
crc = updcrc16(type, 0);
- for (i=0; i<4; i++)
+ for (i=0; i<4; i++)
{
- zsend_ascii(*hdr);
+ zsend_ascii(*hdr);
crc = updcrc16((0377 & *hdr++), crc);
}
crc = updcrc16(0,updcrc16(0,crc));
- zsend_ascii(crc>>8);
+ zsend_ascii(crc>>8);
zsend_ascii(crc);
/* send display control cmd */
zsend_line(015); zsend_line(0212);
if (type != ZFIN && type != ZACK)
- zsend_line(021);
- TxCRC = 0; /* clear tx crc type */
-
+ zsend_line(021);
+ TxCRC = 0; /* clear tx crc type */
+
return;
}
/* send binary data,with frameend */
void zsend_bin_data(rt_uint8_t *buf, rt_int16_t len, rt_uint8_t frameend)
-{
+{
rt_int16_t i,c,tmp;
- rt_uint32_t crc;
+ rt_uint32_t crc;
- if (TxCRC == 0) /* send binary data with 16bits crc check */
- {
+ if (TxCRC == 0) /* send binary data with 16bits crc check */
+ {
crc = 0x0L;
- for (i=0;i<len;i++)
+ for (i=0;i<len;i++)
{
- zsend_zdle_char(*buf);
+ zsend_zdle_char(*buf);
crc = updcrc16((0377 & *buf++), crc);
}
zsend_byte(ZDLE); zsend_byte(frameend);
crc = updcrc16(frameend, crc);
crc = updcrc16(0,updcrc16(0,crc));
- zsend_zdle_char(crc>>8);
- zsend_zdle_char(crc);
- }
- else if (TxCRC == 1) /* send binary data with 32 bits crc check */
- {
+ zsend_zdle_char(crc>>8);
+ zsend_zdle_char(crc);
+ }
+ else if (TxCRC == 1) /* send binary data with 32 bits crc check */
+ {
crc = 0xffffffffL;
- for (i=0;i<len;i++)
+ for (i=0;i<len;i++)
{
c = *buf++ & 0377;
zsend_zdle_char(c);
@@ -201,254 +201,254 @@ void zsend_bin_data(rt_uint8_t *buf, rt_int16_t len, rt_uint8_t frameend)
zsend_byte(ZDLE); zsend_byte(frameend);
crc = updcrc32(frameend, crc);
crc = ~crc;
- for (i=0;i<4;i++)
+ for (i=0;i<4;i++)
{
zsend_zdle_char((int)crc); crc >>= 8;
- }
- }
- else if (TxCRC == 2) /* send binary data with 32bits crc check,RLE encode */
- {
- crc = 0xffffffffL;
+ }
+ }
+ else if (TxCRC == 2) /* send binary data with 32bits crc check,RLE encode */
+ {
+ crc = 0xffffffffL;
tmp = *buf++ & 0377;
- for (i = 0; --len >= 0; ++buf)
+ for (i = 0; --len >= 0; ++buf)
{
- if ((c = *buf & 0377) == tmp && i < 126 && len>0)
+ if ((c = *buf & 0377) == tmp && i < 126 && len>0)
{
++i; continue;
}
- if (i==0)
+ if (i==0)
{
zsend_zdle_char(tmp);
crc = updcrc32(tmp, crc);
- if (tmp == ZRESC)
+ if (tmp == ZRESC)
{
zsend_zdle_char(0100); crc = updcrc32(0100, crc);
}
- tmp = c;
- }
- else if (i == 1)
- {
- if (tmp != ZRESC)
+ tmp = c;
+ }
+ else if (i == 1)
+ {
+ if (tmp != ZRESC)
{
zsend_zdle_char(tmp); zsend_zdle_char(tmp);
crc = updcrc32(tmp, crc);
crc = updcrc32(tmp, crc);
i = 0; tmp = c;
- }
-
- }
- else
- {
+ }
+
+ }
+ else
+ {
zsend_zdle_char(ZRESC); crc = updcrc32(ZRESC, crc);
- if (tmp == 040 && i < 34)
+ if (tmp == 040 && i < 34)
{
i += 036;
- zsend_zdle_char(i);
+ zsend_zdle_char(i);
crc = updcrc32(i, crc);
}
- else
+ else
{
i += 0101;
zsend_zdle_char(i); crc = updcrc32(i, crc);
zsend_zdle_char(tmp); crc = updcrc32(tmp, crc);
}
- i = 0; tmp = c;
+ i = 0; tmp = c;
}
}
zsend_byte(ZDLE); zsend_byte(frameend);
crc = updcrc32(frameend, crc);
crc = ~crc;
- for (i=0;i<4;i++)
+ for (i=0;i<4;i++)
{
- zsend_zdle_char(crc);
+ zsend_zdle_char(crc);
crc >>= 8;
- }
+ }
}
if (frameend == ZCRCW)
- zsend_byte(XON);
-
+ zsend_byte(XON);
+
return;
-}
-
-/* receive data,with 16bits CRC check */
-static rt_int16_t zrec_data16(rt_uint8_t *buf, rt_uint16_t len)
-{
+}
+
+/* receive data,with 16bits CRC check */
+static rt_int16_t zrec_data16(rt_uint8_t *buf, rt_uint16_t len)
+{
rt_int16_t c,crc_cnt;
- rt_uint16_t crc;
- rt_err_t res = -RT_ERROR;
- rt_uint8_t *p,flag = 0;
-
- p = buf;
- crc_cnt = 0; crc = 0L;
+ rt_uint16_t crc;
+ rt_err_t res = -RT_ERROR;
+ rt_uint8_t *p,flag = 0;
+
+ p = buf;
+ crc_cnt = 0; crc = 0L;
Rxcount = 0;
- while(buf <= p+len)
- {
- if ((res = zread_byte()) & ~0377)
- {
- if (res == GOTCRCE || res == GOTCRCG ||
- res == GOTCRCQ || res == GOTCRCW)
- {
- c = res;
+ while(buf <= p+len)
+ {
+ if ((res = zread_byte()) & ~0377)
+ {
+ if (res == GOTCRCE || res == GOTCRCG ||
+ res == GOTCRCQ || res == GOTCRCW)
+ {
c = res;
- crc = updcrc16(res&0377, crc);
- flag = 1;
- continue;
- }
- else if (res == GOTCAN) return ZCAN;
- else if (res == TIMEOUT) return TIMEOUT;
- else return res;
-
- }
- else
- {
- if (flag)
- {
- crc = updcrc16(res, crc);
- crc_cnt++;
- if (crc_cnt < 2) continue;
- if ((crc & 0xffff))
- {
+ c = res;
+ crc = updcrc16(res&0377, crc);
+ flag = 1;
+ continue;
+ }
+ else if (res == GOTCAN) return ZCAN;
+ else if (res == TIMEOUT) return TIMEOUT;
+ else return res;
+
+ }
+ else
+ {
+ if (flag)
+ {
+ crc = updcrc16(res, crc);
+ crc_cnt++;
+ if (crc_cnt < 2) continue;
+ if ((crc & 0xffff))
+ {
#ifdef ZDEBUG
- rt_kprintf("error code: CRC16 error \r\n");
+ rt_kprintf("error code: CRC16 error \r\n");
#endif
- return -RT_ERROR;
- }
- return c;
- }
- else
- {
- *buf++ = res;
- Rxcount++;
- crc = updcrc16(res, crc);
- }
+ return -RT_ERROR;
+ }
+ return c;
+ }
+ else
+ {
+ *buf++ = res;
+ Rxcount++;
+ crc = updcrc16(res, crc);
+ }
}
- }
-
- return -RT_ERROR;
-}
+ }
+
+ return -RT_ERROR;
+}
/* receive data,with 32bits CRC check */
static rt_int16_t zrec_data32(rt_uint8_t *buf, rt_int16_t len)
{
rt_int16_t c,crc_cnt;
rt_uint32_t crc;
- rt_err_t res = -RT_ERROR;
- rt_uint8_t *p,flag = 0;
+ rt_err_t res = -RT_ERROR;
+ rt_uint8_t *p,flag = 0;
- crc_cnt = 0; crc = 0xffffffffL;
+ crc_cnt = 0; crc = 0xffffffffL;
Rxcount = 0;
- while (buf <= p+len)
- {
- if ((res = zread_byte()) & ~0377)
- {
- if (res == GOTCRCE || res == GOTCRCG ||
- res == GOTCRCQ || res == GOTCRCW)
- {
+ while (buf <= p+len)
+ {
+ if ((res = zread_byte()) & ~0377)
+ {
+ if (res == GOTCRCE || res == GOTCRCG ||
+ res == GOTCRCQ || res == GOTCRCW)
+ {
c = res;
- crc = updcrc32(res&0377, crc);
- flag = 1;
- continue;
- }
- else if (res == GOTCAN) return ZCAN;
- else if (res == TIMEOUT) return TIMEOUT;
- else return res;
-
- }
- else
- {
- if (flag)
- {
- crc = updcrc32(res, crc);
- crc_cnt++;
- if (crc_cnt < 4) continue;
- if ((crc & 0xDEBB20E3))
- {
+ crc = updcrc32(res&0377, crc);
+ flag = 1;
+ continue;
+ }
+ else if (res == GOTCAN) return ZCAN;
+ else if (res == TIMEOUT) return TIMEOUT;
+ else return res;
+
+ }
+ else
+ {
+ if (flag)
+ {
+ crc = updcrc32(res, crc);
+ crc_cnt++;
+ if (crc_cnt < 4) continue;
+ if ((crc & 0xDEBB20E3))
+ {
#ifdef ZDEBUG
- rt_kprintf("error code: CRC32 error \r\n");
+ rt_kprintf("error code: CRC32 error \r\n");
#endif
- return -RT_ERROR;
- }
- return c;
- }
- else
- {
- *buf++ = res;
- Rxcount++;
- crc = updcrc32(res, crc);
- }
+ return -RT_ERROR;
+ }
+ return c;
+ }
+ else
+ {
+ *buf++ = res;
+ Rxcount++;
+ crc = updcrc32(res, crc);
+ }
}
- }
+ }
return -RT_ERROR;
-}
+}
/* receive data,with RLE encoded,32bits CRC check */
static rt_int16_t zrec_data32r(rt_uint8_t *buf, rt_int16_t len)
{
rt_int16_t c,crc_cnt;
rt_uint32_t crc;
- rt_err_t res = -RT_ERROR;
- rt_uint8_t *p,flag = 0;
+ rt_err_t res = -RT_ERROR;
+ rt_uint8_t *p,flag = 0;
- crc_cnt = 0; crc = 0xffffffffL;
- Rxcount = 0;
+ crc_cnt = 0; crc = 0xffffffffL;
+ Rxcount = 0;
p = buf;
- while (buf <= p+len)
+ while (buf <= p+len)
{
- if ((res = zread_byte()) & ~0377)
- {
- if (res == GOTCRCE || res == GOTCRCG ||
- res == GOTCRCQ || res == GOTCRCW)
- {
+ if ((res = zread_byte()) & ~0377)
+ {
+ if (res == GOTCRCE || res == GOTCRCG ||
+ res == GOTCRCQ || res == GOTCRCW)
+ {
c = res;
- crc = updcrc32(res&0377, crc);
- flag = 1;
- continue;
- }
- else if (res == GOTCAN) return ZCAN;
- else if (res == TIMEOUT) return TIMEOUT;
- else return res;
-
- }
- else
- {
- if (flag)
- {
- crc = updcrc32(res, crc);
- crc_cnt++;
- if (crc_cnt < 4) continue;
- if ((crc & 0xDEBB20E3))
- {
+ crc = updcrc32(res&0377, crc);
+ flag = 1;
+ continue;
+ }
+ else if (res == GOTCAN) return ZCAN;
+ else if (res == TIMEOUT) return TIMEOUT;
+ else return res;
+
+ }
+ else
+ {
+ if (flag)
+ {
+ crc = updcrc32(res, crc);
+ crc_cnt++;
+ if (crc_cnt < 4) continue;
+ if ((crc & 0xDEBB20E3))
+ {
#ifdef ZDEBUG
- rt_kprintf("error code: CRC32 error \r\n");
+ rt_kprintf("error code: CRC32 error \r\n");
#endif
- return -RT_ERROR;
- }
- return c;
- }
- else
- {
+ return -RT_ERROR;
+ }
+ return c;
+ }
+ else
+ {
crc = updcrc32(res, crc);
- switch (c)
+ switch (c)
{
case 0:
- if (res == ZRESC)
+ if (res == ZRESC)
{
c = -1; continue;
}
- *buf++ = res;
- Rxcount++;
+ *buf++ = res;
+ Rxcount++;
continue;
case -1:
- if (res >= 040 && res < 0100)
+ if (res >= 040 && res < 0100)
{
- c = res - 035; res = 040;
+ c = res - 035; res = 040;
goto spaces;
}
- if (res == 0100)
+ if (res == 0100)
{
c = 0;
- *buf++ = ZRESC;
- Rxcount++;
+ *buf++ = ZRESC;
+ Rxcount++;
continue;
}
c = res; continue;
@@ -459,14 +459,14 @@ static rt_int16_t zrec_data32r(rt_uint8_t *buf, rt_int16_t len)
spaces:
if ((buf + c) > p+len)
goto end;
- while ( --res >= 0)
+ while ( --res >= 0)
{
- *buf++ = res;
- Rxcount++;
+ *buf++ = res;
+ Rxcount++;
}
c = 0; continue;
- }
- }
+ }
+ }
} // if -else
}
@@ -475,105 +475,105 @@ end:
}
rt_int16_t zget_data(rt_uint8_t *buf, rt_uint16_t len)
{
- rt_int16_t res = -RT_ERROR;
-
- if (RxCRC == 0)
- {
- res = zrec_data16(buf,len);
- }
- else if (RxCRC == 1)
- {
- res = zrec_data32(buf, len);
- }
- else if (RxCRC == 2)
- {
- res = zrec_data32r(buf, len);
- }
-
+ rt_int16_t res = -RT_ERROR;
+
+ if (RxCRC == 0)
+ {
+ res = zrec_data16(buf,len);
+ }
+ else if (RxCRC == 1)
+ {
+ res = zrec_data32(buf, len);
+ }
+ else if (RxCRC == 2)
+ {
+ res = zrec_data32r(buf, len);
+ }
+
return res;
}
/* get type and cmd of header, fix lenght */
rt_int16_t zget_header(rt_uint8_t *hdr)
{
- rt_int16_t c,prev_char;
+ rt_int16_t c,prev_char;
rt_uint32_t bit;
- rt_uint16_t get_can,step_out;
+ rt_uint16_t get_can,step_out;
bit = get_device_baud(); /* get console baud rate */
Rxframeind = header_type = 0;
- step_out = 0;
- prev_char = 0xff;
- for (;;)
- {
- c = zread_line(100);
- switch(c)
- {
- case 021:
- case 0221:
- if (prev_char == CAN) break;
- if (prev_char == ZCRCW) goto start_again;
- break;
- case RCDO:
- goto end;
- case TIMEOUT:
- if (prev_char == CAN) break;
- if (prev_char == ZCRCW)
- {
- c = -RT_ERROR; goto end;
- }
- goto end;
- case ZCRCW:
- if (prev_char == CAN) goto start_again;
- break;
- case CAN:
-get_can:
- if (++get_can > 5)
- {
- c = ZCAN; goto end;
- }
- break;
- case ZPAD:
- if (prev_char == CAN) break;
- if (prev_char == ZCRCW) goto start_again;
- step_out = 1;
- break;
- default:
- if (prev_char == CAN) break;
- if (prev_char == ZCRCW) goto start_again;
-start_again:
- if (--bit == 0)
- {
- c = GCOUNT; goto end;
- }
- get_can = 0;
- break;
- }
- prev_char = c;
- if (step_out) break; /* exit loop */
- }
- step_out = get_can = 0;
- for (;;)
- {
- c = zxor_read();
- switch(c)
- {
- case ZPAD:
- break;
- case RCDO:
- case TIMEOUT:
- goto end;
- case ZDLE:
- step_out = 1;
- break;
- default:
- goto start_again;
- }
- if (step_out) break;
+ step_out = 0;
+ prev_char = 0xff;
+ for (;;)
+ {
+ c = zread_line(100);
+ switch(c)
+ {
+ case 021:
+ case 0221:
+ if (prev_char == CAN) break;
+ if (prev_char == ZCRCW) goto start_again;
+ break;
+ case RCDO:
+ goto end;
+ case TIMEOUT:
+ if (prev_char == CAN) break;
+ if (prev_char == ZCRCW)
+ {
+ c = -RT_ERROR; goto end;
+ }
+ goto end;
+ case ZCRCW:
+ if (prev_char == CAN) goto start_again;
+ break;
+ case CAN:
+get_can:
+ if (++get_can > 5)
+ {
+ c = ZCAN; goto end;
+ }
+ break;
+ case ZPAD:
+ if (prev_char == CAN) break;
+ if (prev_char == ZCRCW) goto start_again;
+ step_out = 1;
+ break;
+ default:
+ if (prev_char == CAN) break;
+ if (prev_char == ZCRCW) goto start_again;
+start_again:
+ if (--bit == 0)
+ {
+ c = GCOUNT; goto end;
+ }
+ get_can = 0;
+ break;
+ }
+ prev_char = c;
+ if (step_out) break; /* exit loop */
+ }
+ step_out = get_can = 0;
+ for (;;)
+ {
+ c = zxor_read();
+ switch(c)
+ {
+ case ZPAD:
+ break;
+ case RCDO:
+ case TIMEOUT:
+ goto end;
+ case ZDLE:
+ step_out = 1;
+ break;
+ default:
+ goto start_again;
+ }
+ if (step_out) break;
}
Rxframeind = c = zxor_read();
- switch (c)
- {
+ switch (c)
+ {
case ZBIN32:
RxCRC = 1; c = zget_bin_fcs(hdr); break;
case ZBINR32:
@@ -583,7 +583,7 @@ start_again:
case ZHEX:
RxCRC = 0; c = zget_hex_header(hdr); break;
case CAN:
- goto get_can;
+ goto get_can;
case RCDO:
case TIMEOUT:
goto end;
@@ -605,7 +605,7 @@ static rt_int16_t zget_bin_header(rt_uint8_t *hdr)
header_type = res;
crc = updcrc16(res, 0);
- for (i=0;i<4;i++)
+ for (i=0;i<4;i++)
{
if ((res = zread_byte()) & ~0377)
return res;
@@ -618,11 +618,11 @@ static rt_int16_t zget_bin_header(rt_uint8_t *hdr)
if ((res = zread_byte()) & ~0377)
return res;
crc = updcrc16(res, crc);
- if (crc & 0xFFFF)
+ if (crc & 0xFFFF)
{
rt_kprintf("CRC error\n");
return -RT_ERROR;
- }
+ }
return header_type;
}
@@ -636,10 +636,10 @@ static rt_int16_t zget_bin_fcs(rt_uint8_t *hdr)
if ((res = zread_byte()) & ~0377)
return res;
header_type = res;
- crc = 0xFFFFFFFFL;
+ crc = 0xFFFFFFFFL;
crc = updcrc32(res, crc);
- for (i=0;i<4;i++) /* 4headers */
+ for (i=0;i<4;i++) /* 4headers */
{
if ((res = zread_byte()) & ~0377)
return res;
@@ -647,20 +647,20 @@ static rt_int16_t zget_bin_fcs(rt_uint8_t *hdr)
*hdr++ = res;
}
- for (i=0;i<4;i++) /* 4bytes crc */
+ for (i=0;i<4;i++) /* 4bytes crc */
{
if ((res = zread_byte()) & ~0377)
return res;
crc = updcrc32(res, crc);
}
- if (crc != 0xDEBB20E3)
- {
+ if (crc != 0xDEBB20E3)
+ {
#ifdef ZDEBUG
- rt_kprintf("CRC error\n");
+ rt_kprintf("CRC error\n");
#endif
return -RT_ERROR;
- }
+ }
return header_type;
}
@@ -670,14 +670,14 @@ static rt_int16_t zget_bin_fcs(rt_uint8_t *hdr)
rt_int16_t zget_hex_header(rt_uint8_t *hdr)
{
rt_int16_t res,i;
- rt_uint16_t crc;
+ rt_uint16_t crc;
if ((res = zget_hex()) < 0)
return res;
header_type = res;
crc = updcrc16(res, 0);
- for (i=0;i<4;i++)
+ for (i=0;i<4;i++)
{
if ((res = zget_hex()) < 0)
return res;
@@ -690,11 +690,11 @@ rt_int16_t zget_hex_header(rt_uint8_t *hdr)
if ((res = zget_hex()) < 0)
return res;
crc = updcrc16(res, crc);
- if (crc & 0xFFFF)
- {
+ if (crc & 0xFFFF)
+ {
#ifdef ZDEBUG
- rt_kprintf("error code : CRC error\r\n");
-#endif
+ rt_kprintf("error code : CRC error\r\n");
+#endif
return -RT_ERROR;
}
res = zread_line(100);
@@ -702,7 +702,7 @@ rt_int16_t zget_hex_header(rt_uint8_t *hdr)
return res;
res = zread_line(100);
if (res < 0)
- return res;
+ return res;
return header_type;
}
@@ -710,11 +710,11 @@ rt_int16_t zget_hex_header(rt_uint8_t *hdr)
/* convert to ascii */
static void zsend_ascii(rt_uint8_t c)
{
- const char hex[] = "0123456789abcdef";
+ const char hex[] = "0123456789abcdef";
zsend_line(hex[(c&0xF0)>>4]);
- zsend_line(hex[(c)&0xF]);
-
+ zsend_line(hex[(c)&0xF]);
+
return;
}
@@ -722,26 +722,26 @@ static void zsend_ascii(rt_uint8_t c)
* aend character c with ZMODEM escape sequence encoding.
*/
void zsend_zdle_char(rt_uint16_t ch)
-{
- rt_uint16_t res;
-
+{
+ rt_uint16_t res;
+
res = ch & 0377;
- switch (res)
+ switch (res)
{
case 0377:
zsend_byte(res);
break;
case ZDLE:
- zsend_byte(ZDLE);
- res ^= 0100;
+ zsend_byte(ZDLE);
+ res ^= 0100;
zsend_byte(res);
break;
- case 021:
+ case 021:
case 023:
- case 0221:
+ case 0221:
case 0223:
- zsend_byte(ZDLE);
- res ^= 0100;
+ zsend_byte(ZDLE);
+ res ^= 0100;
zsend_byte(res);
break;
default:
@@ -752,7 +752,7 @@ void zsend_zdle_char(rt_uint16_t ch)
/* decode two lower case hex digits into an 8 bit byte value */
static rt_int16_t zget_hex(void)
{
- rt_int16_t res,n;
+ rt_int16_t res,n;
if ((res = zxor_read()) < 0)
return res;
@@ -768,7 +768,7 @@ static rt_int16_t zget_hex(void)
res -= ('a' - ':');
if (res & ~0x0f)
return -RT_ERROR;
- res += (n<<4);
+ res += (n<<4);
return res;
}
@@ -786,7 +786,7 @@ again:
/* Quick check for non control characters */
if ((res = zread_line(100)) & 0140)
return res;
- switch (res)
+ switch (res)
{
case ZDLE:
break;
@@ -807,7 +807,7 @@ again2:
return res;
if (res == CAN && (res = zread_line(100)) < 0)
return res;
- switch (res)
+ switch (res)
{
case CAN:
return GOTCAN;
@@ -829,7 +829,7 @@ again2:
if ((res & 0140) == 0100)
return (res ^ 0100);
break;
- }
+ }
return -RT_ERROR;
}
@@ -842,7 +842,7 @@ rt_int16_t zxor_read(void)
{
rt_int16_t res;
- for (;;)
+ for (;;)
{
if ((res = zread_line(100)) < 0)
return res;
@@ -852,11 +852,11 @@ rt_int16_t zxor_read(void)
continue;
case '\r':
case '\n':
- case ZDLE:
+ case ZDLE:
default:
return res;
}
- }
+ }
}
@@ -866,8 +866,8 @@ void zput_pos(rt_uint32_t pos)
tx_header[ZP0] = pos;
tx_header[ZP1] = pos>>8;
tx_header[ZP2] = pos>>16;
- tx_header[ZP3] = pos>>24;
-
+ tx_header[ZP3] = pos>>24;
+
return;
}
@@ -877,9 +877,9 @@ void zget_pos(rt_uint32_t pos)
Rxpos = (rx_header[ZP3] & 0377);
Rxpos = (Rxpos << 8) | (rx_header[ZP2] & 0377);
Rxpos = (Rxpos << 8) | (rx_header[ZP1] & 0377);
- Rxpos = (Rxpos << 8) | (rx_header[ZP0] & 0377);
-
+ Rxpos = (Rxpos << 8) | (rx_header[ZP0] & 0377);
+
return;
-}
+}
-/* end of zcore.c */
+/* end of zcore.c */
diff --git a/components/utilities/zmodem/zdef.h b/components/utilities/zmodem/zdef.h
index 14df3412ad..3568bdfd96 100644
--- a/components/utilities/zmodem/zdef.h
+++ b/components/utilities/zmodem/zdef.h
@@ -1,7 +1,7 @@
-#ifndef __ZDEF_H__
-#define __ZDEF_H__
-
-#include <rtthread.h>
+#ifndef __ZDEF_H__
+#define __ZDEF_H__
+
+#include <rtthread.h>
#include "crc.h"
#define ZPAD '*' /* 052 padding character begins frames */
#define ZDLE 030 /* ctrl-X ZMODEM escape - `ala BISYNC DLE */
@@ -121,7 +121,7 @@ extern char Attn[ZATTNLEN+1]; /* Attention string rx sends to tx on err */
/* globals used by ZMODEM functions */
extern rt_uint8_t Rxframeind; /* ZBIN ZBIN32, or ZHEX type of frame */
-extern char header_type; /* type of header received */
+extern char header_type; /* type of header received */
extern rt_uint8_t rx_header[4]; /* received header */
extern rt_uint8_t tx_header[4]; /* transmitted header */
extern rt_uint8_t Txfcs32; /* TRUE means send binary frames with 32 bit FCS */
@@ -129,18 +129,18 @@ extern rt_uint16_t Rxcount; /* count of data bytes received */
extern rt_uint16_t Rxtimeout; /* tenths of seconds to wait for something */
extern rt_uint32_t Rxpos; /* received file position */
extern rt_uint32_t Txpos; /* transmitted file position */
-extern rt_uint8_t Txfcs32; /* TURE means send binary frames with 32 bit FCS */
-
+extern rt_uint8_t Txfcs32; /* TURE means send binary frames with 32 bit FCS */
+
/* ward Christensen / CP/M parameters - Don't change these! */
#define ENQ 005
#define CAN ('X'&037)
#define XOFF ('s'&037)
#define XON ('q'&037)
#define SOH 1
-#define STX 2
-#define ETX 3
-#define SYN 026
-#define ESC 033
+#define STX 2
+#define ETX 3
+#define SYN 026
+#define ESC 033
#define WANTG 0107 /* send G not NAK to get nonstop batch xmsn */
#define EOT 4
#define ACK 6
@@ -154,64 +154,64 @@ extern rt_uint8_t Txfcs32; /* TURE means send binary frames with 32 bit
#define RETRYMAX 5
#define WCEOT (-10)
-
-
-
-
-#define BITRATE 115200
-#define TX_BUFFER_SIZE 1024
-#define RX_BUFFER_SIZE 1024 /* sender or receiver's max buffer size */
+
+
+
+
+#define BITRATE 115200
+#define TX_BUFFER_SIZE 1024
+#define RX_BUFFER_SIZE 1024 /* sender or receiver's max buffer size */
extern char ZF0_CMD; /* local ZMODEM file conversion request */
-extern char ZF1_CMD; /* local ZMODEM file management request */
-extern char ZF2_CMD; /* local ZMODEM file management request */
-extern char ZF3_CMD; /* local ZMODEM file management request */
-extern rt_uint32_t Baudrate ;
-extern rt_uint32_t Left_bytes;
-extern rt_uint32_t Left_sizes;
-
-
-struct zmodemf
-{
- struct rt_semaphore zsem;
- rt_device_t device;
-};
-extern struct zmodemf zmodem;
-
-struct zfile
-{
- char *fname;
+extern char ZF1_CMD; /* local ZMODEM file management request */
+extern char ZF2_CMD; /* local ZMODEM file management request */
+extern char ZF3_CMD; /* local ZMODEM file management request */
+extern rt_uint32_t Baudrate ;
+extern rt_uint32_t Left_bytes;
+extern rt_uint32_t Left_sizes;
+
+
+struct zmodemf
+{
+ struct rt_semaphore zsem;
+ rt_device_t device;
+};
+extern struct zmodemf zmodem;
+
+struct zfile
+{
+ char *fname;
rt_int32_t fd;
- rt_uint32_t ctime;
+ rt_uint32_t ctime;
rt_uint32_t mode;
rt_uint32_t bytes_total;
rt_uint32_t bytes_sent;
rt_uint32_t bytes_received;
- rt_uint32_t file_end;
-
-};
-extern struct finsh_shell* shell;
-
-#define ZDEBUG 0
-/* sz.c */
-extern void zs_start(char *path);
-/* rz.c */
-extern void zr_start(char *path);
-
-/* zcore.c */
-extern void zinit_parameter(void);
-extern rt_int16_t zget_header(rt_uint8_t *hdr);
-extern void zsend_bin_header(rt_uint8_t type, rt_uint8_t *hdr);
-extern void zsend_hex_header(rt_uint8_t type, rt_uint8_t *hdr);
-extern rt_int16_t zget_data(rt_uint8_t *buf, rt_uint16_t len);
-extern void zsend_bin_data(rt_uint8_t *buf, rt_int16_t len, rt_uint8_t frameend);
-extern void zput_pos(rt_uint32_t pos);
-extern void zget_pos(rt_uint32_t pos);
-/* zdevice.c */
-extern rt_uint32_t get_device_baud(void);
-extern void zsend_byte(rt_uint16_t c);
-extern void zsend_line(rt_uint16_t c);
-extern rt_int16_t zread_line(rt_uint16_t timeout);
-extern void zsend_break(char *cmd);
+ rt_uint32_t file_end;
+
+};
+extern struct finsh_shell* shell;
+
+#define ZDEBUG 0
+/* sz.c */
+extern void zs_start(char *path);
+/* rz.c */
+extern void zr_start(char *path);
+
+/* zcore.c */
+extern void zinit_parameter(void);
+extern rt_int16_t zget_header(rt_uint8_t *hdr);
+extern void zsend_bin_header(rt_uint8_t type, rt_uint8_t *hdr);
+extern void zsend_hex_header(rt_uint8_t type, rt_uint8_t *hdr);
+extern rt_int16_t zget_data(rt_uint8_t *buf, rt_uint16_t len);
+extern void zsend_bin_data(rt_uint8_t *buf, rt_int16_t len, rt_uint8_t frameend);
+extern void zput_pos(rt_uint32_t pos);
+extern void zget_pos(rt_uint32_t pos);
+/* zdevice.c */
+extern rt_uint32_t get_device_baud(void);
+extern void zsend_byte(rt_uint16_t c);
+extern void zsend_line(rt_uint16_t c);
+extern rt_int16_t zread_line(rt_uint16_t timeout);
+extern void zsend_break(char *cmd);
extern void zsend_can(void);
-
+
#endif /* __ZDEF_H__ */
diff --git a/components/utilities/zmodem/zdevice.c b/components/utilities/zmodem/zdevice.c
index 6bf57d3b9c..1562cc5f5c 100644
--- a/components/utilities/zmodem/zdevice.c
+++ b/components/utilities/zmodem/zdevice.c
@@ -1,79 +1,79 @@
/*
- * File : zdevice.c
+ * File : zdevice.c
* the implemention of zmodem protocol.
* Change Logs:
* Date Author Notes
* 2011-03-29 itspy
- */
-
-#include <rtthread.h>
-#include <finsh.h>
-#include <shell.h>
-#include <rtdef.h>
-#include <dfs.h>
-#include <dfs_file.h>
-#include <dfs_posix.h>
-#include "zdef.h"
+ */
+
+#include <rtthread.h>
+#include <finsh.h>
+#include <shell.h>
+#include <rtdef.h>
+#include <dfs.h>
+#include <dfs_file.h>
+#include <dfs_posix.h>
+#include "zdef.h"
-rt_uint32_t Line_left = 0; /* left number of data in the read line buffer*/
-rt_uint32_t Left_sizes = 0; /* left file sizes */
+rt_uint32_t Line_left = 0; /* left number of data in the read line buffer*/
+rt_uint32_t Left_sizes = 0; /* left file sizes */
rt_uint32_t Baudrate = BITRATE; /* console baudrate */
-
-
-
-rt_uint32_t get_device_baud(void)
-{
- return(Baudrate);
-}
-
-rt_uint32_t get_sys_time(void)
-{
- return(0L);
-}
-
-void zsend_byte(rt_uint16_t ch)
-{
- rt_device_write(zmodem.device, 0, &ch,1);
-
- return;
-}
-
-void zsend_line(rt_uint16_t c)
-{
- rt_uint16_t ch;
-
- ch = (c & 0377);
- rt_device_write(zmodem.device, 0, &ch, 1);
-
- return;
-}
+
+
+
+rt_uint32_t get_device_baud(void)
+{
+ return(Baudrate);
+}
+
+rt_uint32_t get_sys_time(void)
+{
+ return(0L);
+}
+
+void zsend_byte(rt_uint16_t ch)
+{
+ rt_device_write(zmodem.device, 0, &ch,1);
+
+ return;
+}
+
+void zsend_line(rt_uint16_t c)
+{
+ rt_uint16_t ch;
+
+ ch = (c & 0377);
+ rt_device_write(zmodem.device, 0, &ch, 1);
+
+ return;
+}
rt_int16_t zread_line(rt_uint16_t timeout)
{
- char *str;
- static char buf[10];
-
- if (Line_left > 0)
- {
- Line_left -= 1;
- return (*str++ & 0377);
- }
- Line_left = 0;
- timeout/=5;
- while (1)
- {
- Line_left = rt_device_read(shell->device, 0, buf, 1);
- if (Line_left)
- {
- Line_left = Line_left;
- str = buf;
- break;
- }
- }
- if (Line_left < 1) return TIMEOUT;
- Line_left -=1;
-
+ char *str;
+ static char buf[10];
+
+ if (Line_left > 0)
+ {
+ Line_left -= 1;
+ return (*str++ & 0377);
+ }
+ Line_left = 0;
+ timeout/=5;
+ while (1)
+ {
+ Line_left = rt_device_read(shell->device, 0, buf, 1);
+ if (Line_left)
+ {
+ Line_left = Line_left;
+ str = buf;
+ break;
+ }
+ }
+ if (Line_left < 1) return TIMEOUT;
+ Line_left -=1;
+
return (*str++ & 0377);
}
@@ -82,33 +82,33 @@ rt_int16_t zread_line(rt_uint16_t timeout)
* and \335 (break signal)
*/
void zsend_break(char *cmd)
-{
+{
- while (*cmd++)
+ while (*cmd++)
{
- switch (*cmd)
+ switch (*cmd)
{
- case '\336':
+ case '\336':
continue;
- case '\335':
- rt_thread_delay(RT_TICK_PER_SECOND);
+ case '\335':
+ rt_thread_delay(RT_TICK_PER_SECOND);
continue;
default:
- zsend_line(*cmd);
+ zsend_line(*cmd);
break;
}
}
-}
+}
/* send cancel string to get the other end to shut up */
void zsend_can(void)
{
- static char cmd[] = {24,24,24,24,24,24,24,24,24,24,0};
+ static char cmd[] = {24,24,24,24,24,24,24,24,24,24,0};
- zsend_break(cmd);
+ zsend_break(cmd);
rt_kprintf("\x0d");
- Line_left=0; /* clear Line_left */
-
+ Line_left=0; /* clear Line_left */
+
return;
-}
+}
/* end of zdevice.c */
diff --git a/components/utilities/zmodem/zstart.c b/components/utilities/zmodem/zstart.c
index f8e19d7e92..e5a36ca7ab 100644
--- a/components/utilities/zmodem/zstart.c
+++ b/components/utilities/zmodem/zstart.c
@@ -1,120 +1,120 @@
/*
- * File : zstart.c
+ * File : zstart.c
* the implemention of zmodem protocol.
* Change Logs:
* Date Author Notes
* 2011-03-29 itspy
- */
-
-#include <rtthread.h>
-#include <finsh.h>
-#include <shell.h>
-#include <dfs.h>
-#include <dfs_file.h>
-#include "zdef.h"
-
-
-
-struct zmodemf zmodem;
-
-rt_err_t zmodem_rx_ind(rt_device_t dev, rt_size_t size)
-{
- /* release semaphore */
- rt_sem_release(&zmodem.zsem);
-
- return RT_EOK;
-}
-
-void finsh_rz(void *parameter)
-{
- char *path;
- rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size);
- rt_uint8_t flag;
-
- flag = RT_DEVICE_FLAG_STREAM;
- zmodem.device->flag &=(~flag);
- rt_sem_init(&(zmodem.zsem), "zsem", 0, 0);
- path = rt_thread_self()->parameter;
- /* save old rx_indicate */
- rx_indicate = zmodem.device->rx_indicate;
- /* set new rx_indicate */
- rt_device_set_rx_indicate(zmodem.device, RT_NULL);
- /* start receive remote files */
- zr_start(path);
- zmodem.device->flag |=flag;
- /* recovery old rx_indicate */
- rt_device_set_rx_indicate(zmodem.device, rx_indicate);
- /* finsh>> */
- rt_kprintf(FINSH_PROMPT);
-}
-void finsh_sz(void *parameter)
-{
- char *path;
- rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size);
- rt_uint8_t flag;
-
- flag = RT_DEVICE_FLAG_STREAM;
- zmodem.device->flag &=(~flag);
- rt_sem_init(&(zmodem.zsem), "zsem", 0, 0);
- path = rt_thread_self()->parameter;
- /* save old rx_indicate */
- rx_indicate = zmodem.device->rx_indicate;
- /* set new rx_indicate */
- rt_device_set_rx_indicate(zmodem.device, zmodem_rx_ind);
- zs_start(path);
- zmodem.device->flag |=flag;
- /* recovery old rx_indicate */
- rt_device_set_rx_indicate(zmodem.device, rx_indicate);
- /* finsh>> */
- rt_kprintf(FINSH_PROMPT);
-}
-
-#ifdef RT_USING_FINSH
-#include <finsh.h>
-#include <shell.h>
-
-static void rz(char *para)
-{
- rt_thread_t init_thread;
- rt_device_t device;
- const char* device_name = finsh_get_device();
-
- device = rt_device_find(device_name);
- if( device == RT_NULL )
- {
- rt_kprintf("%s not find\r\n",device_name);
- }
- zmodem.device = device;
- init_thread = rt_thread_create("rz",
- finsh_rz,
- (void*)para,
- 2048,
- rt_thread_self()->current_priority+1,
- 20);
-
- if (init_thread != RT_NULL) rt_thread_startup(init_thread);
-}
-FINSH_FUNCTION_EXPORT(rz, receive files by zmodem protocol)
-static void sz(char *para)
-{
- rt_thread_t init_thread;
- rt_device_t device;
- const char* device_name = finsh_get_device();
-
- device = rt_device_find(device_name);
- if( device == RT_NULL )
- {
- rt_kprintf("%s not find\r\n",device_name);
- }
- zmodem.device = device;
- init_thread = rt_thread_create("sz",
- finsh_sz,
- (void*)para,
- 2048,
- rt_thread_self()->current_priority+1,
- 20);
-
- if (init_thread != RT_NULL) rt_thread_startup(init_thread);
-}
-FINSH_FUNCTION_EXPORT(sz, send files by zmodem protocol)
-#endif
+ */
+
+#include <rtthread.h>
+#include <finsh.h>
+#include <shell.h>
+#include <dfs.h>
+#include <dfs_file.h>
+#include "zdef.h"
+
+
+
+struct zmodemf zmodem;
+
+rt_err_t zmodem_rx_ind(rt_device_t dev, rt_size_t size)
+{
+ /* release semaphore */
+ rt_sem_release(&zmodem.zsem);
+
+ return RT_EOK;
+}
+
+void finsh_rz(void *parameter)
+{
+ char *path;
+ rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size);
+ rt_uint8_t flag;
+
+ flag = RT_DEVICE_FLAG_STREAM;
+ zmodem.device->flag &=(~flag);
+ rt_sem_init(&(zmodem.zsem), "zsem", 0, 0);
+ path = rt_thread_self()->parameter;
+ /* save old rx_indicate */
+ rx_indicate = zmodem.device->rx_indicate;
+ /* set new rx_indicate */
+ rt_device_set_rx_indicate(zmodem.device, RT_NULL);
+ /* start receive remote files */
+ zr_start(path);
+ zmodem.device->flag |=flag;
+ /* recovery old rx_indicate */
+ rt_device_set_rx_indicate(zmodem.device, rx_indicate);
+ /* finsh>> */
+ rt_kprintf(FINSH_PROMPT);
+}
+void finsh_sz(void *parameter)
+{
+ char *path;
+ rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size);
+ rt_uint8_t flag;
+
+ flag = RT_DEVICE_FLAG_STREAM;
+ zmodem.device->flag &=(~flag);
+ rt_sem_init(&(zmodem.zsem), "zsem", 0, 0);
+ path = rt_thread_self()->parameter;
+ /* save old rx_indicate */
+ rx_indicate = zmodem.device->rx_indicate;
+ /* set new rx_indicate */
+ rt_device_set_rx_indicate(zmodem.device, zmodem_rx_ind);
+ zs_start(path);
+ zmodem.device->flag |=flag;
+ /* recovery old rx_indicate */
+ rt_device_set_rx_indicate(zmodem.device, rx_indicate);
+ /* finsh>> */
+ rt_kprintf(FINSH_PROMPT);
+}
+
+#ifdef RT_USING_FINSH
+#include <finsh.h>
+#include <shell.h>
+
+static void rz(char *para)
+{
+ rt_thread_t init_thread;
+ rt_device_t device;
+ const char* device_name = finsh_get_device();
+
+ device = rt_device_find(device_name);
+ if( device == RT_NULL )
+ {
+ rt_kprintf("%s not find\r\n",device_name);
+ }
+ zmodem.device = device;
+ init_thread = rt_thread_create("rz",
+ finsh_rz,
+ (void*)para,
+ 2048,
+ rt_thread_self()->current_priority+1,
+ 20);
+
+ if (init_thread != RT_NULL) rt_thread_startup(init_thread);
+}
+FINSH_FUNCTION_EXPORT(rz, receive files by zmodem protocol)
+static void sz(char *para)
+{
+ rt_thread_t init_thread;
+ rt_device_t device;
+ const char* device_name = finsh_get_device();
+
+ device = rt_device_find(device_name);
+ if( device == RT_NULL )
+ {
+ rt_kprintf("%s not find\r\n",device_name);
+ }
+ zmodem.device = device;
+ init_thread = rt_thread_create("sz",
+ finsh_sz,
+ (void*)para,
+ 2048,
+ rt_thread_self()->current_priority+1,
+ 20);
+
+ if (init_thread != RT_NULL) rt_thread_startup(init_thread);
+}
+FINSH_FUNCTION_EXPORT(sz, send files by zmodem protocol)
+#endif
generated by cgit v1.3.1 (git 2.54.0) at 2026-10-30 14:00:10 +0000