fix wrong gbprinter crc and use proper status flag checks

src/gbprinter.c

 };
 
 struct prn_header {
-    uint16_t magic;
     uint8_t command;
     uint8_t compression;
     uint16_t length;
 static void prn_send_block(uint8_t *data, uint16_t length, uint16_t *crc) {
     while (length-- > 0) {
         uint8_t v = *data;
-        *crc += v;
         *data = prn_send_receive(v);
         data++;
+
+        if (crc) {
+            *crc += v;
+        }
     }
 }
 
 static enum PRN_STATUS printer_send_command(enum PRN_CMDS cmd,
                                             uint8_t *data, uint16_t length) {
-    static struct prn_header header;
-    static struct prn_footer footer;
-    uint16_t crc = 0;
+    uint16_t magic = PRN_MAGIC;
+    prn_send_block((uint8_t *)&magic, sizeof(uint16_t), NULL);
 
-    header.magic = PRN_MAGIC;
+    static struct prn_header header;
     header.command = cmd;
     header.compression = 0;
     header.length = data ? length : 0;
 
-    footer.crc = 0;
-    footer.alive = 0;
-    footer.status = 0;
-
+    uint16_t crc = 0;
     prn_send_block((uint8_t *)&header, sizeof(struct prn_header), &crc);
+
     if (data && (length > 0)) {
         prn_send_block(data, length, &crc);
     }
 
+    static struct prn_footer footer;
     footer.crc = crc;
-    prn_send_block((uint8_t *)&footer, sizeof(struct prn_footer), &crc);
+    footer.alive = 0;
+    footer.status = 0;
+
+    prn_send_block((uint8_t *)&footer, sizeof(struct prn_footer), NULL);
 
     enum PRN_STATUS r = footer.status;
     if (footer.alive != PRN_MAGIC_DETECT) {
     enum PRN_STATUS error = PRN_STATUS_OK;
 
     while (1) {
-#ifdef DEBUG
-        error = (error & 0xF000) | printer_send_command(PRN_CMD_STATUS, NULL, 0);
-#else
         error = printer_send_command(PRN_CMD_STATUS, NULL, 0);
-#endif // DEBUG
         if ((error & mask) == value) {
             break;
         }
 
-#ifdef DEBUG
-        EMU_printf("%s: 0x%04x\n",  __func__, (uint16_t)error);
-
-        uint8_t n = (error & 0xF000) >> 12;
-        n = (n + 1) & 0x000F;
-        error = (error & 0x0FFF) | (n << 12);
-#endif // DEBUG
-
         if (printer_check_cancel()) {
             printer_send_command(PRN_CMD_BREAK, NULL, 0);
             error |= PRN_STATUS_CANCELLED;
 #ifdef DEBUG
     EMU_printf("%s: 0x%04x\n",  __func__, (uint16_t)r);
 #endif // DEBUG
-    return r | PRN_STATUS_DETECT;
+    return r | PRN_STATUS_AT_DETECT;
 }
 
 static void win_str_helper(const char *s, uint8_t y_pos) {
 
         r = printer_send_command(PRN_CMD_DATA, tile_buff, sizeof(tile_buff));
         if ((r & ~PRN_STATUS_UNTRAN) != PRN_STATUS_OK) {
+            r |= PRN_STATUS_AT_DATA;
             goto end;
         }
 
         if (printer_check_cancel()) {
             printer_send_command(PRN_CMD_BREAK, NULL, 0);
-            r = PRN_STATUS_CANCELLED;
+            r |= PRN_STATUS_CANCELLED;
             goto end;
         }
     }
     printer_send_command(PRN_CMD_PRINT, (uint8_t *)&params, sizeof(struct prn_config));
 
     r = printer_wait(PRN_BUSY_TIMEOUT, PRN_STATUS_BUSY, PRN_STATUS_BUSY);
-    if (r & PRN_STATUS_MASK_ERRORS) {
+    if ((r & ~(PRN_STATUS_FULL | PRN_STATUS_TIMEOUT)) & PRN_STATUS_MASK_ERRORS) {
+        r |= PRN_STATUS_AT_BUSY;
         goto end;
     }
 
     r = printer_wait(PRN_PRINT_TIMEOUT, PRN_STATUS_BUSY, 0);
-    if (r & PRN_STATUS_MASK_ERRORS) {
+    if ((r & ~PRN_STATUS_FULL) & PRN_STATUS_MASK_ERRORS) {
+        r |= PRN_STATUS_AT_FINAL;
         goto end;
     }
 
 #ifdef DEBUG
     EMU_printf("%s: 0x%04x\n",  __func__, (uint16_t)r);
 #endif // DEBUG
-    return r;
+    return (r & ~PRN_STATUS_FULL);
 }

src/gbprinter.h

 #include <stdint.h>
 
 enum PRN_STATUS {
+    PRN_STATUS_OK          = 0x0000, // everything is fine
+
     // status flags from printer
-    PRN_STATUS_LOWBAT      = 0x80, // battery too low
-    PRN_STATUS_ER2         = 0x40, // unspecified error
-    PRN_STATUS_ER1         = 0x20, // paper jam
-    PRN_STATUS_ER0         = 0x10, // packet error
-    PRN_STATUS_UNTRAN      = 0x08, // unprinted data in buffer
-    PRN_STATUS_FULL        = 0x04, // ready, triggered by DATA with len 0
-    PRN_STATUS_BUSY        = 0x02, // printer is printing
-    PRN_STATUS_CHECKSUM    = 0x01, // checksum error
-    PRN_STATUS_OK          = 0x00, // everything is fine
+    PRN_STATUS_CHECKSUM    = 0x0001, // checksum error
+    PRN_STATUS_BUSY        = 0x0002, // printer is printing
+    PRN_STATUS_FULL        = 0x0004, // ready, triggered by DATA with len 0
+    PRN_STATUS_UNTRAN      = 0x0008, // unprinted data in buffer
+    PRN_STATUS_ER0         = 0x0010, // packet error
+    PRN_STATUS_ER1         = 0x0020, // paper jam
+    PRN_STATUS_ER2         = 0x0040, // unspecified error
+    PRN_STATUS_LOWBAT      = 0x0080, // battery too low
 
     // status flags from driver code
-    PRN_STATUS_CANCELLED   = 0x100, // user has aborted the print by pressing B
-    PRN_STATUS_TIMEOUT     = 0x200, // timeout waiting for printer response
-    PRN_STATUS_NO_MAGIC    = 0x400, // printer did not respond with proper 'alive'
+    PRN_STATUS_CANCELLED   = 0x0100, // user has aborted the print by pressing B
+    PRN_STATUS_TIMEOUT     = 0x0200, // timeout waiting for printer response
+    PRN_STATUS_NO_MAGIC    = 0x0400, // printer did not respond with proper 'alive'
 
     // status flags for user code
-    PRN_STATUS_DETECT      = 0x800, // set in gbprinter_detect
+    PRN_STATUS_AT_DETECT   = 0x0800, // set in gbprinter_detect
+    PRN_STATUS_AT_DATA     = 0x1000, // set at abort on tile data
+    PRN_STATUS_AT_BUSY     = 0x2000, // set at abort on busy wait print
+    PRN_STATUS_AT_FINAL    = 0x4000, // set at abort on final wait
 
     // masks to check for errors
-    PRN_STATUS_MASK_ERRORS = 0x7F0,
-    PRN_STATUS_MASK_ANY    = 0x7FF,
+    PRN_STATUS_MASK_ERRORS = 0x07F0,
+    PRN_STATUS_MASK_ANY    = 0x07FF,
 };
 
 #define PRN_PALETTE_NORMAL 0b11100100u

src/gbprinter_error.c

 
 BANKREF(gbprinter_error)
 
-#define ERROR_BITS 12
+#define ERROR_BITS 15
 
 static const char str_ok[] = "ok";
 
-static const char str_lowbat[] = "battery too low";
-static const char str_er2[] = "unknown error";
-static const char str_er1[] = "paper jam";
-static const char str_er0[] = "packet error";
-static const char str_untran[] = "unprocessed";
-static const char str_full[] = "data full";
-static const char str_busy[] = "printer busy";
-static const char str_sum[] = "checksum error";
-static const char str_cancel[] = "cancelled";
-static const char str_timeout[] = "timeout";
-static const char str_magic[] = "wrong magic byte";
-static const char str_detect[] = "@ detection";
+static const char       str_sum[] = "checksum error";
+static const char      str_busy[] = "printer busy";
+static const char      str_full[] = "data full";
+static const char    str_untran[] = "unprocessed";
+static const char       str_er0[] = "packet error";
+static const char       str_er1[] = "paper jam";
+static const char       str_er2[] = "unknown error";
+static const char    str_lowbat[] = "battery too low";
+static const char    str_cancel[] = "cancelled";
+static const char   str_timeout[] = "timeout";
+static const char     str_magic[] = "wrong magic byte";
+static const char str_at_detect[] = "@ detection";
+static const char   str_at_data[] = "@ tile data";
+static const char   str_at_busy[] = "@ busy wait";
+static const char  str_at_final[] = "@ final wait";
 
 static const char * const error_strings[ERROR_BITS] = {
-    str_sum, str_busy, str_full, str_untran,
-    str_er0, str_er1, str_er2, str_lowbat,
-    str_cancel, str_timeout, str_magic, str_detect,
+    str_sum,     str_busy,    str_full,     str_untran,
+    str_er0,     str_er1,     str_er2,      str_lowbat,
+    str_cancel,  str_timeout, str_magic,    str_at_detect,
+    str_at_data, str_at_busy, str_at_final,
 };
 
 uint8_t gbprinter_error(enum PRN_STATUS status, char *buff) BANKED {

src/main.c

                 status = gbprinter_screenshot(1, is_black ? PRN_PALETTE_SC_B : PRN_PALETTE_SC_W);
             }
 
-            win_score_clear(2, 0);
-            win_score_print(status);
-            while (1) {
-                key_read();
-                if (key_pressed(0xFF)) break;
-                vsync();
+            if (status != PRN_STATUS_OK) {
+                win_score_clear(2, 0);
+                win_score_print(status);
+                while (1) {
+                    key_read();
+                    if (key_pressed(0xFF)) break;
+                    vsync();
+                }
             }
 
             break;