My Marlin configs for Fabrikator Mini and CTC i3 Pro B
Du kan inte välja fler än 25 ämnen Ämnen måste starta med en bokstav eller siffra, kan innehålla bindestreck ('-') och vara max 35 tecken långa.

binary_protocol.h 16KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475
  1. /**
  2. * Marlin 3D Printer Firmware
  3. * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  4. *
  5. * Based on Sprinter and grbl.
  6. * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
  7. *
  8. * This program is free software: you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License as published by
  10. * the Free Software Foundation, either version 3 of the License, or
  11. * (at your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License
  19. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  20. *
  21. */
  22. #pragma once
  23. #include "../inc/MarlinConfig.h"
  24. #define BINARY_STREAM_COMPRESSION
  25. #if ENABLED(BINARY_STREAM_COMPRESSION)
  26. #include "../libs/heatshrink/heatshrink_decoder.h"
  27. #endif
  28. inline bool bs_serial_data_available(const uint8_t index) {
  29. switch (index) {
  30. case 0: return MYSERIAL0.available();
  31. #if NUM_SERIAL > 1
  32. case 1: return MYSERIAL1.available();
  33. #endif
  34. }
  35. return false;
  36. }
  37. inline int bs_read_serial(const uint8_t index) {
  38. switch (index) {
  39. case 0: return MYSERIAL0.read();
  40. #if NUM_SERIAL > 1
  41. case 1: return MYSERIAL1.read();
  42. #endif
  43. }
  44. return -1;
  45. }
  46. #if ENABLED(BINARY_STREAM_COMPRESSION)
  47. static heatshrink_decoder hsd;
  48. static uint8_t decode_buffer[512] = {};
  49. #endif
  50. class SDFileTransferProtocol {
  51. private:
  52. struct Packet {
  53. struct [[gnu::packed]] Open {
  54. static bool validate(char* buffer, size_t length) {
  55. return (length > sizeof(Open) && buffer[length - 1] == '\0');
  56. }
  57. static Open& decode(char* buffer) {
  58. data = &buffer[2];
  59. return *reinterpret_cast<Open*>(buffer);
  60. }
  61. bool compression_enabled() { return compression & 0x1; }
  62. bool dummy_transfer() { return dummy & 0x1; }
  63. static char* filename() { return data; }
  64. private:
  65. uint8_t dummy, compression;
  66. static char* data; // variable length strings complicate things
  67. };
  68. };
  69. static bool file_open(char* filename) {
  70. if (!dummy_transfer) {
  71. card.mount();
  72. card.openFile(filename, false);
  73. if (!card.isFileOpen()) return false;
  74. }
  75. transfer_active = true;
  76. data_waiting = 0;
  77. #if ENABLED(BINARY_STREAM_COMPRESSION)
  78. heatshrink_decoder_reset(&hsd);
  79. #endif
  80. return true;
  81. }
  82. static bool file_write(char* buffer, const size_t length) {
  83. #if ENABLED(BINARY_STREAM_COMPRESSION)
  84. if (compression) {
  85. size_t total_processed = 0, processed_count = 0;
  86. HSD_poll_res presult;
  87. while (total_processed < length) {
  88. heatshrink_decoder_sink(&hsd, reinterpret_cast<uint8_t*>(&buffer[total_processed]), length - total_processed, &processed_count);
  89. total_processed += processed_count;
  90. do {
  91. presult = heatshrink_decoder_poll(&hsd, &decode_buffer[data_waiting], sizeof(decode_buffer) - data_waiting, &processed_count);
  92. data_waiting += processed_count;
  93. if (data_waiting == sizeof(decode_buffer)) {
  94. if (!dummy_transfer)
  95. if (card.write(decode_buffer, data_waiting) < 0) {
  96. return false;
  97. }
  98. data_waiting = 0;
  99. }
  100. } while (presult == HSDR_POLL_MORE);
  101. }
  102. return true;
  103. }
  104. #endif
  105. return (dummy_transfer || card.write(buffer, length) >= 0);
  106. }
  107. static bool file_close() {
  108. if (!dummy_transfer) {
  109. #if ENABLED(BINARY_STREAM_COMPRESSION)
  110. // flush any buffered data
  111. if (data_waiting) {
  112. if (card.write(decode_buffer, data_waiting) < 0) return false;
  113. data_waiting = 0;
  114. }
  115. #endif
  116. card.closefile();
  117. card.release();
  118. }
  119. #if ENABLED(BINARY_STREAM_COMPRESSION)
  120. heatshrink_decoder_finish(&hsd);
  121. #endif
  122. transfer_active = false;
  123. return true;
  124. }
  125. static void transfer_abort() {
  126. if (!dummy_transfer) {
  127. card.closefile();
  128. card.removeFile(card.filename);
  129. card.release();
  130. #if ENABLED(BINARY_STREAM_COMPRESSION)
  131. heatshrink_decoder_finish(&hsd);
  132. #endif
  133. }
  134. transfer_active = false;
  135. return;
  136. }
  137. enum class FileTransfer : uint8_t { QUERY, OPEN, CLOSE, WRITE, ABORT };
  138. static size_t data_waiting, transfer_timeout, idle_timeout;
  139. static bool transfer_active, dummy_transfer, compression;
  140. public:
  141. static void idle() {
  142. // If a transfer is interrupted and a file is left open, abort it after TIMEOUT ms
  143. const millis_t ms = millis();
  144. if (transfer_active && ELAPSED(ms, idle_timeout)) {
  145. idle_timeout = ms + IDLE_PERIOD;
  146. if (ELAPSED(ms, transfer_timeout)) transfer_abort();
  147. }
  148. }
  149. static void process(uint8_t packet_type, char* buffer, const uint16_t length) {
  150. transfer_timeout = millis() + TIMEOUT;
  151. switch (static_cast<FileTransfer>(packet_type)) {
  152. case FileTransfer::QUERY:
  153. SERIAL_ECHOPAIR("PFT:version:", VERSION_MAJOR, ".", VERSION_MINOR, ".", VERSION_PATCH);
  154. #if ENABLED(BINARY_STREAM_COMPRESSION)
  155. SERIAL_ECHOLNPAIR(":compresion:heatshrink,", HEATSHRINK_STATIC_WINDOW_BITS, ",", HEATSHRINK_STATIC_LOOKAHEAD_BITS);
  156. #else
  157. SERIAL_ECHOLNPGM(":compresion:none");
  158. #endif
  159. break;
  160. case FileTransfer::OPEN:
  161. if (transfer_active)
  162. SERIAL_ECHOLNPGM("PFT:busy");
  163. else {
  164. if (Packet::Open::validate(buffer, length)) {
  165. auto packet = Packet::Open::decode(buffer);
  166. compression = packet.compression_enabled();
  167. dummy_transfer = packet.dummy_transfer();
  168. if (file_open(packet.filename())) {
  169. SERIAL_ECHOLNPGM("PFT:success");
  170. break;
  171. }
  172. }
  173. SERIAL_ECHOLNPGM("PFT:fail");
  174. }
  175. break;
  176. case FileTransfer::CLOSE:
  177. if (transfer_active) {
  178. if (file_close())
  179. SERIAL_ECHOLNPGM("PFT:success");
  180. else
  181. SERIAL_ECHOLNPGM("PFT:ioerror");
  182. }
  183. else SERIAL_ECHOLNPGM("PFT:invalid");
  184. break;
  185. case FileTransfer::WRITE:
  186. if (!transfer_active)
  187. SERIAL_ECHOLNPGM("PFT:invalid");
  188. else if (!file_write(buffer, length))
  189. SERIAL_ECHOLNPGM("PFT:ioerror");
  190. break;
  191. case FileTransfer::ABORT:
  192. transfer_abort();
  193. SERIAL_ECHOLNPGM("PFT:success");
  194. break;
  195. default:
  196. SERIAL_ECHOLNPGM("PTF:invalid");
  197. break;
  198. }
  199. }
  200. static const uint16_t VERSION_MAJOR = 0, VERSION_MINOR = 1, VERSION_PATCH = 0, TIMEOUT = 10000, IDLE_PERIOD = 1000;
  201. };
  202. class BinaryStream {
  203. public:
  204. enum class Protocol : uint8_t { CONTROL, FILE_TRANSFER };
  205. enum class ProtocolControl : uint8_t { SYNC = 1, CLOSE };
  206. enum class StreamState : uint8_t { PACKET_RESET, PACKET_WAIT, PACKET_HEADER, PACKET_DATA, PACKET_FOOTER,
  207. PACKET_PROCESS, PACKET_RESEND, PACKET_TIMEOUT, PACKET_ERROR };
  208. struct Packet { // 10 byte protocol overhead, ascii with checksum and line number has a minimum of 7 increasing with line
  209. union Header {
  210. static constexpr uint16_t HEADER_TOKEN = 0xB5AD;
  211. struct [[gnu::packed]] {
  212. uint16_t token; // packet start token
  213. uint8_t sync; // stream sync, resend id and packet loss detection
  214. uint8_t meta; // 4 bit protocol,
  215. // 4 bit packet type
  216. uint16_t size; // data length
  217. uint16_t checksum; // header checksum
  218. };
  219. uint8_t protocol() { return (meta >> 4) & 0xF; }
  220. uint8_t type() { return meta & 0xF; }
  221. void reset() { token = 0; sync = 0; meta = 0; size = 0; checksum = 0; }
  222. uint8_t data[1];
  223. };
  224. union Footer {
  225. struct [[gnu::packed]] {
  226. uint16_t checksum; // full packet checksum
  227. };
  228. void reset() { checksum = 0; }
  229. uint8_t data[1];
  230. };
  231. Header header;
  232. Footer footer;
  233. uint32_t bytes_received;
  234. uint16_t checksum, header_checksum;
  235. millis_t timeout;
  236. char* buffer;
  237. void reset() {
  238. header.reset();
  239. footer.reset();
  240. bytes_received = 0;
  241. checksum = 0;
  242. header_checksum = 0;
  243. timeout = millis() + PACKET_MAX_WAIT;
  244. buffer = nullptr;
  245. }
  246. } packet{};
  247. void reset() {
  248. sync = 0;
  249. packet_retries = 0;
  250. buffer_next_index = 0;
  251. }
  252. // fletchers 16 checksum
  253. uint32_t checksum(uint32_t cs, uint8_t value) {
  254. uint16_t cs_low = (((cs & 0xFF) + value) % 255);
  255. return ((((cs >> 8) + cs_low) % 255) << 8) | cs_low;
  256. }
  257. // read the next byte from the data stream keeping track of
  258. // whether the stream times out from data starvation
  259. // takes the data variable by reference in order to return status
  260. bool stream_read(uint8_t& data) {
  261. if (stream_state != StreamState::PACKET_WAIT && ELAPSED(millis(), packet.timeout)) {
  262. stream_state = StreamState::PACKET_TIMEOUT;
  263. return false;
  264. }
  265. if (!bs_serial_data_available(card.transfer_port_index)) return false;
  266. data = bs_read_serial(card.transfer_port_index);
  267. packet.timeout = millis() + PACKET_MAX_WAIT;
  268. return true;
  269. }
  270. template<const size_t buffer_size>
  271. void receive(char (&buffer)[buffer_size]) {
  272. uint8_t data = 0;
  273. millis_t transfer_window = millis() + RX_TIMESLICE;
  274. #if ENABLED(SDSUPPORT)
  275. PORT_REDIRECT(card.transfer_port_index);
  276. #endif
  277. while (PENDING(millis(), transfer_window)) {
  278. switch (stream_state) {
  279. /**
  280. * Data stream packet handling
  281. */
  282. case StreamState::PACKET_RESET:
  283. packet.reset();
  284. stream_state = StreamState::PACKET_WAIT;
  285. case StreamState::PACKET_WAIT:
  286. if (!stream_read(data)) { idle(); return; } // no active packet so don't wait
  287. packet.header.data[1] = data;
  288. if (packet.header.token == packet.header.HEADER_TOKEN) {
  289. packet.bytes_received = 2;
  290. stream_state = StreamState::PACKET_HEADER;
  291. }
  292. else {
  293. // stream corruption drop data
  294. packet.header.data[0] = data;
  295. }
  296. break;
  297. case StreamState::PACKET_HEADER:
  298. if (!stream_read(data)) break;
  299. packet.header.data[packet.bytes_received++] = data;
  300. packet.checksum = checksum(packet.checksum, data);
  301. // header checksum calculation can't contain the checksum
  302. if (packet.bytes_received == sizeof(Packet::header) - 2)
  303. packet.header_checksum = packet.checksum;
  304. if (packet.bytes_received == sizeof(Packet::header)) {
  305. if (packet.header.checksum == packet.header_checksum) {
  306. // The SYNC control packet is a special case in that it doesn't require the stream sync to be correct
  307. if (static_cast<Protocol>(packet.header.protocol()) == Protocol::CONTROL && static_cast<ProtocolControl>(packet.header.type()) == ProtocolControl::SYNC) {
  308. SERIAL_ECHOLNPAIR("ss", sync, ",", buffer_size, ",", VERSION_MAJOR, ".", VERSION_MINOR, ".", VERSION_PATCH);
  309. stream_state = StreamState::PACKET_RESET;
  310. break;
  311. }
  312. if (packet.header.sync == sync) {
  313. buffer_next_index = 0;
  314. packet.bytes_received = 0;
  315. if (packet.header.size) {
  316. stream_state = StreamState::PACKET_DATA;
  317. packet.buffer = static_cast<char *>(&buffer[0]); // multipacket buffering not implemented, always allocate whole buffer to packet
  318. }
  319. else
  320. stream_state = StreamState::PACKET_PROCESS;
  321. }
  322. else if (packet.header.sync == sync - 1) { // ok response must have been lost
  323. SERIAL_ECHOLNPAIR("ok", packet.header.sync); // transmit valid packet received and drop the payload
  324. stream_state = StreamState::PACKET_RESET;
  325. }
  326. else if (packet_retries) {
  327. stream_state = StreamState::PACKET_RESET; // could be packets already buffered on flow controlled connections, drop them without ack
  328. }
  329. else {
  330. SERIAL_ECHO_MSG("Datastream packet out of order");
  331. stream_state = StreamState::PACKET_RESEND;
  332. }
  333. }
  334. else {
  335. SERIAL_ECHO_START();
  336. SERIAL_ECHOLNPAIR("Packet header(", packet.header.sync, "?) corrupt");
  337. stream_state = StreamState::PACKET_RESEND;
  338. }
  339. }
  340. break;
  341. case StreamState::PACKET_DATA:
  342. if (!stream_read(data)) break;
  343. if (buffer_next_index < buffer_size)
  344. packet.buffer[buffer_next_index] = data;
  345. else {
  346. SERIAL_ECHO_MSG("Datastream packet data buffer overrun");
  347. stream_state = StreamState::PACKET_ERROR;
  348. break;
  349. }
  350. packet.checksum = checksum(packet.checksum, data);
  351. packet.bytes_received++;
  352. buffer_next_index++;
  353. if (packet.bytes_received == packet.header.size) {
  354. stream_state = StreamState::PACKET_FOOTER;
  355. packet.bytes_received = 0;
  356. }
  357. break;
  358. case StreamState::PACKET_FOOTER:
  359. if (!stream_read(data)) break;
  360. packet.footer.data[packet.bytes_received++] = data;
  361. if (packet.bytes_received == sizeof(Packet::footer)) {
  362. if (packet.footer.checksum == packet.checksum) {
  363. stream_state = StreamState::PACKET_PROCESS;
  364. }
  365. else {
  366. SERIAL_ECHO_START();
  367. SERIAL_ECHOLNPAIR("Packet(", packet.header.sync, ") payload corrupt");
  368. stream_state = StreamState::PACKET_RESEND;
  369. }
  370. }
  371. break;
  372. case StreamState::PACKET_PROCESS:
  373. sync++;
  374. packet_retries = 0;
  375. bytes_received += packet.header.size;
  376. SERIAL_ECHOLNPAIR("ok", packet.header.sync); // transmit valid packet received
  377. dispatch();
  378. stream_state = StreamState::PACKET_RESET;
  379. break;
  380. case StreamState::PACKET_RESEND:
  381. if (packet_retries < MAX_RETRIES || MAX_RETRIES == 0) {
  382. packet_retries++;
  383. stream_state = StreamState::PACKET_RESET;
  384. SERIAL_ECHO_START();
  385. SERIAL_ECHOLNPAIR("Resend request ", int(packet_retries));
  386. SERIAL_ECHOLNPAIR("rs", sync);
  387. }
  388. else
  389. stream_state = StreamState::PACKET_ERROR;
  390. break;
  391. case StreamState::PACKET_TIMEOUT:
  392. SERIAL_ECHO_MSG("Datastream timeout");
  393. stream_state = StreamState::PACKET_RESEND;
  394. break;
  395. case StreamState::PACKET_ERROR:
  396. SERIAL_ECHOLNPAIR("fe", packet.header.sync);
  397. reset(); // reset everything, resync required
  398. stream_state = StreamState::PACKET_RESET;
  399. break;
  400. }
  401. }
  402. }
  403. void dispatch() {
  404. switch(static_cast<Protocol>(packet.header.protocol())) {
  405. case Protocol::CONTROL:
  406. switch(static_cast<ProtocolControl>(packet.header.type())) {
  407. case ProtocolControl::CLOSE: // revert back to ASCII mode
  408. card.flag.binary_mode = false;
  409. break;
  410. default:
  411. SERIAL_ECHO_MSG("Unknown BinaryProtocolControl Packet");
  412. }
  413. break;
  414. case Protocol::FILE_TRANSFER:
  415. SDFileTransferProtocol::process(packet.header.type(), packet.buffer, packet.header.size); // send user data to be processed
  416. break;
  417. default:
  418. SERIAL_ECHO_MSG("Unsupported Binary Protocol");
  419. }
  420. }
  421. void idle() {
  422. // Some Protocols may need periodic updates without new data
  423. SDFileTransferProtocol::idle();
  424. }
  425. static const uint16_t PACKET_MAX_WAIT = 500, RX_TIMESLICE = 20, MAX_RETRIES = 0, VERSION_MAJOR = 0, VERSION_MINOR = 1, VERSION_PATCH = 0;
  426. uint8_t packet_retries, sync;
  427. uint16_t buffer_next_index;
  428. uint32_t bytes_received;
  429. StreamState stream_state = StreamState::PACKET_RESET;
  430. };
  431. extern BinaryStream binaryStream[NUM_SERIAL];