feat: Assemble / show full POST codes on display

Author: tuxuser

firmware/userapp/Core/Inc/display.h

@@ -15,7 +15,7 @@ extern I2C_HandleTypeDef hi2c2;
 void Display_Init(void);
 void Display_Print(const char *message);
 void Display_ScrollText(const char *text);
-void Display_ShowCode(uint16_t code, uint8_t segment);
+void Display_ShowCode(uint64_t code, const char *flavor);
 void Display_Tick(void);
 
 #ifdef __cplusplus

firmware/userapp/Core/Inc/postcodes.h

@@ -8,6 +8,9 @@ extern "C" {
 #include "main.h"
 #include "slave.h"
 
+#define SEGMENT_FLAVOR_MASK 0xF0
+#define SEGMENT_INDEX_MASK  0x0F
+
 // Indicated by Segments-register
 enum CodeFlavor: uint8_t {
     CODE_FLAVOR_CPU = 0x10,
@@ -16,6 +19,11 @@ enum CodeFlavor: uint8_t {
     CODE_FLAVOR_OS =  0xF0,
 };
 
+typedef struct {
+    uint64_t code;
+    uint8_t flavor;
+} PostCode;
+
 enum MAX6958Registers {
     REG_NoOp = 0x00,
     REG_DecodeMode = 0x01,
@@ -34,10 +42,13 @@ enum MAX6958Registers {
     REG_Segments = 0x24,
 };
 
-uint16_t POST_ReadCode();
-uint8_t POST_ReadSegment();
-const char *POST_GetSegmentName(uint8_t seg);
-char POST_GetSegmentIndex(uint8_t seg);
+const char *POST_GetSegmentName(uint8_t flavor);
+
+// Feeds the current Digit0-3/Segments registers into the code assembler.
+// A full POST code is made up of up to 4 consecutive Segments-writes of the
+// same flavor (MSB-first, terminated by index 1); returns 1 and fills *out
+// once a full code has been assembled, 0 otherwise.
+uint8_t POST_ProcessSegment(PostCode *out);
 
 #ifdef __cplusplus
 }

firmware/userapp/Core/Src/display.c

@@ -11,8 +11,6 @@
 static u8g2_t myDisplay;
 
 static char lcd_buf[20] = {0};
-static const char *seg_name = NULL;
-static char seg_index_str[] = {'(', 'X', ')' ,'\0'};
 
 uint8_t u8x8_gpio_and_delay(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
 {
@@ -136,20 +134,45 @@ void Display_Init(void)
     u8g2_ClearDisplay(&myDisplay);
 }
 
-void Display_ShowCode(uint16_t code, uint8_t segment) {
-    seg_name = POST_GetSegmentName(segment);
-    // Convert numeric index to ASCII character
-    seg_index_str[1] = POST_GetSegmentIndex(segment) + '0';
+static void drawCenteredStr(int16_t y, const char *str) {
+    int16_t x = (64 - u8g2_GetStrWidth(&myDisplay, str)) / 2;
+    if (x < 0) {
+        x = 0;
+    }
+    u8g2_DrawStr(&myDisplay, x, y, str);
+}
 
-    // Assemble content
-    snprintf(lcd_buf, sizeof(lcd_buf), "%04X", code);
+void Display_ShowCode(uint64_t code, const char *flavor) {
+    // Unpadded hex digit count, to decide layout below.
+    uint64_t tmp = code;
+    int digits = 1;
+    while (tmp > 0xF) {
+        tmp >>= 4;
+        digits++;
+    }
 
     u8g2_ClearDisplay(&myDisplay);
-    u8g2_SetFont(&myDisplay, u8g2_font_luBS14_tr);
-    u8g2_DrawStr(&myDisplay, 4, 32, lcd_buf);
-    u8g2_SetFont(&myDisplay, u8g2_font_7x13_mr);
-    u8g2_DrawStr(&myDisplay, 12, 10, seg_name);
-    u8g2_DrawStr(&myDisplay, 40, 10, seg_index_str);
+
+    u8g2_SetFont(&myDisplay, u8g2_font_5x7_mr);
+    u8g2_DrawStr(&myDisplay, 2, 7, flavor);
+
+    if (digits <= 8) {
+        // Fits in 32 bits: single, bigger line.
+        char buf[9];
+        snprintf(buf, sizeof(buf), "%lX", (unsigned long)code);
+        u8g2_SetFont(&myDisplay, u8g2_font_7x13_mr);
+        drawCenteredStr(30, buf);
+    } else {
+        // Longer code: split across two lines, one 32-bit half each.
+        char hiBuf[9];
+        char loBuf[9];
+        snprintf(hiBuf, sizeof(hiBuf), "%lX", (unsigned long)(code >> 32));
+        snprintf(loBuf, sizeof(loBuf), "%lX", (unsigned long)code);
+        u8g2_SetFont(&myDisplay, u8g2_font_6x10_mr);
+        drawCenteredStr(18, hiBuf);
+        drawCenteredStr(29, loBuf);
+    }
+
     u8g2_SendBuffer(&myDisplay);
 }
 
@@ -160,13 +183,12 @@ void Display_ShowCode(uint16_t code, uint8_t segment) {
   */
 void Display_Tick(void)
 {
+    PostCode postCode;
+
     if (Slave_HardError()) {
         Display_Print("BUS ERROR");
-    } else if (Slave_IsNewSegmentAvailable()) {
-        Display_ShowCode(
-            POST_ReadCode(),
-            POST_ReadSegment()
-        );
+    } else if (Slave_IsNewSegmentAvailable() && POST_ProcessSegment(&postCode)) {
+        Display_ShowCode(postCode.code, POST_GetSegmentName(postCode.flavor));
     } else if (Button_IsPressed()) {
         Display_Print("BtnPress");
     }

firmware/userapp/Core/Src/postcodes.c

@@ -1,18 +1,33 @@
 #include "postcodes.h"
 
-uint16_t POST_ReadCode() {
-    return (Slave_RegRead(REG_Digit0) & 0x0F)
-        | ((Slave_RegRead(REG_Digit1) & 0x0F) << 4)
-        | ((Slave_RegRead(REG_Digit2) & 0x0F) << 8)
-        | ((Slave_RegRead(REG_Digit3) & 0x0F) << 12);
+#define POST_CODE_WORD_COUNT 4
+
+static uint16_t codeWords[POST_CODE_WORD_COUNT] = {0};
+static uint8_t currFlavor = 0;
+static uint8_t currIndex = 0; // 0 == no pending accumulation
+// Set when a blank (index 0) Segments-write of the same flavor as the
+// pending accumulation is observed; consumed by the next real segment to
+// prove it's a genuine continuation rather than an unrelated/abandoned one.
+static uint8_t sawContinuationMarker = 0;
+
+static void resetCodeWords(void) {
+    for (int i = 0; i < POST_CODE_WORD_COUNT; i++) {
+        codeWords[i] = 0;
+    }
+    currIndex = 0;
+    sawContinuationMarker = 0;
 }
 
-uint8_t POST_ReadSegment() {
-    return Slave_RegRead(REG_Segments);
+static uint64_t assembleCode(void) {
+    uint64_t code = 0;
+    for (int i = 0; i < POST_CODE_WORD_COUNT; i++) {
+        code |= (uint64_t)codeWords[i] << (16 * i);
+    }
+    return code;
 }
 
-const char *POST_GetSegmentName(uint8_t seg) {
-    switch (seg & 0xF0) {
+const char *POST_GetSegmentName(uint8_t flavor) {
+    switch (flavor & SEGMENT_FLAVOR_MASK) {
         case CODE_FLAVOR_CPU:
             return "CPU";
         case CODE_FLAVOR_SP:
@@ -26,6 +41,53 @@ const char *POST_GetSegmentName(uint8_t seg) {
     }
 }
 
-char POST_GetSegmentIndex(uint8_t seg) {
-    return seg & 0x0F;
-}
+uint8_t POST_ProcessSegment(PostCode *out) {
+    uint8_t segByte = Slave_RegRead(REG_Segments);
+    uint8_t flavor = segByte & SEGMENT_FLAVOR_MASK;
+    uint8_t rawIndex = segByte & SEGMENT_INDEX_MASK;
+
+    if (rawIndex == 0) {
+        // Blank write: no digit data, but the console sends it between
+        // every part of a genuine multi-part code tagged with that code's flavor.
+        if (currIndex != 0 && flavor == currFlavor) {
+            sawContinuationMarker = 1;
+        }
+        return 0;
+    }
+
+    uint8_t code_idx;
+    switch (rawIndex) {
+        case 1: code_idx = 0; break;
+        case 2: code_idx = 1; break;
+        case 4: code_idx = 2; break;
+        case 8: code_idx = 3; break;
+        default: return 0;
+    }
+
+    uint8_t isContinuation = currIndex != 0 && sawContinuationMarker && flavor == currFlavor;
+    if (currIndex != 0 && !isContinuation) {
+        // Pending accumulation was never continued (no matching blank
+        // marker seen); discard it instead of merging stale digits into
+        // this segment.
+        resetCodeWords();
+    }
+
+    codeWords[code_idx] = (Slave_RegRead(REG_Digit0) & 0x0F)
+        | ((Slave_RegRead(REG_Digit1) & 0x0F) << 4)
+        | ((Slave_RegRead(REG_Digit2) & 0x0F) << 8)
+        | ((Slave_RegRead(REG_Digit3) & 0x0F) << 12);
+    currFlavor = flavor;
+    currIndex = rawIndex;
+    sawContinuationMarker = 0;
+
+    // Codes come in MSB-first (index order: 8, 4, 2, 1)
+    // When index is 1, full code was transmitted from console
+    if (rawIndex != 1) {
+        return 0;
+    }
+
+    out->code = assembleCode();
+    out->flavor = currFlavor;
+    resetCodeWords();
+    return 1;
+}