entryPointCPP.cpp

/*
 * entryPointCPP.cpp
 *
 *  Created on: Jan 26, 2025
 *      Author: johng
 */
 
#include <stdio.h>
#include <string.h>
#include <new>
#include "entryPointCPP.hpp"
#include "Adafruit_RA8875.h"
#include "MB85RS64V.hpp"
#include "touchCalibrationStorage.hpp"
#ifdef TOUCH_CALIBRATION_ENABLE
#include "touchCalibration.hpp"
#endif
 
Adafruit_RA8875 *tft = nullptr;
 
static MB85RS64V *fram = nullptr;
 
static tsMatrix_t touchMatrix;
static bool touchMatrixValid = false;
 
void initTest(SPI_HandleTypeDef *halSPI) {
    // nothrow: return nullptr on failure instead of throwing, then check it before use
    tft = new (std::nothrow) Adafruit_RA8875(halSPI, RA8875_CS_GPIO_Port, RA8875_CS_Pin,
            LCD_RESET_GPIO_Port, LCD_RESET_Pin);
    if (tft == nullptr) {
        printf("RA8875 object could not be allocated (out of heap)\r\n");
        Error_Handler();
        return;
    }
 
    if (tft->begin(RA8875_800x480)) {
        printf("RA8875 Found\r\n");
    } else {
        printf("RA8875 not found (expected chip ID 0x75)\r\n");
        Error_Handler();
        return;
    }
}
 
void testLCD(bool buildTest) {
    if (tft == nullptr) {       // initTest() has not run yet; fail loudly instead of dereferencing NULL
        printf("ERROR: testLCD() called before initTest()\r\n");
        Error_Handler();
    }
 
    if (buildTest) {
        printf("================  Graphics Mode =============\r\n");
 
      tft->displayOn(true);
      HAL_Delay(1);
      tft->GPIOX(true);
      HAL_Delay(1);
      tft->PWM1config(true, RA8875_PWM_CLK_DIV1024);
      tft->PWM1out(255);
      HAL_Delay(1);
 
      tft->graphicsMode();
 
      printf("FillSreen White\r\n");
      tft->fillScreen(RA8875_WHITE);
 
      HAL_Delay(1000);
#ifdef PWM
      // Play with PWM
      printf("Start: Play with PWM\r\n");
 
      for (uint8_t i=255; i!=0; i-=5 )
      {
        tft->PWM1out(i);
        delay(100);
      }
      for (uint8_t i=0; i!=255; i+=5 )
      {
        tft->PWM1out(i);
        delay(100);
      }
      tft->PWM1out(255);
 
      printf("END: Play with PWM\r\n");
      HAL_Delay(2000);
#endif
      printf("FillSreen Red\r\n");
      tft->fillScreen(RA8875_RED);
      HAL_Delay(1000);
      printf("FillSreen Yellow\r\n");
      tft->fillScreen(RA8875_YELLOW);
      HAL_Delay(1000);
      printf("FillSreen Green\r\n");
      tft->fillScreen(RA8875_GREEN);
      HAL_Delay(1000);
      printf("FillSreen Cyan\r\n");
      tft->fillScreen(RA8875_CYAN);
      HAL_Delay(1000);
      printf("FillSreen Magenta\r\n");
      tft->fillScreen(RA8875_MAGENTA);
      HAL_Delay(1000);
      printf("FillSreen Black\r\n");
      tft->fillScreen(RA8875_BLACK);
      HAL_Delay(1000);
 
      // Try some GFX acceleration!
      printf("drawCircle\r\n");
      tft->drawCircle(100, 100, 50, RA8875_BLACK);
      printf("fillCircle\r\n");
      tft->fillCircle(100, 100, 49, RA8875_GREEN);
 
      HAL_Delay(1000);
 
      printf("fillRect\r\n");
      tft->fillRect(11, 11, 398, 198, RA8875_BLUE);
      HAL_Delay(1000);
      printf("drawRect\r\n");
      tft->drawRect(10, 10, 400, 200, RA8875_GREEN);
      HAL_Delay(1000);
      printf("fillRoundRect\r\n");
      tft->fillRoundRect(200, 10, 200, 100, 10, RA8875_RED);
      HAL_Delay(1000);
      printf("drawPixel\r\n");
      tft->drawPixel(10,10,RA8875_BLACK);
      HAL_Delay(1000);
      printf("drawPixel\r\n");
      tft->drawPixel(11,11,RA8875_BLACK);
      HAL_Delay(1000);
      printf("drawLine\r\n");
      tft->drawLine(10, 10, 200, 100, RA8875_RED);
      HAL_Delay(1000);
      printf("drawTriangle\r\n");
      tft->drawTriangle(200, 15, 250, 100, 150, 125, RA8875_BLACK);
      HAL_Delay(1000);
      printf("fillTriangle\r\n");
      tft->fillTriangle(200, 16, 249, 99, 151, 124, RA8875_YELLOW);
      HAL_Delay(1000);
      printf("drawEllipse\r\n");
      tft->drawEllipse(300, 100, 100, 40, RA8875_BLACK);
      HAL_Delay(1000);
      printf("fillEllipse\r\n");
      tft->fillEllipse(300, 100, 98, 38, RA8875_GREEN);
      HAL_Delay(1000);
      // Argument 5 (curvePart) is a 2-bit value to control each corner (select 0, 1, 2, or 3)
      printf("drawCurve\r\n");
      tft->drawCurve(50, 100, 80, 40, 2, RA8875_BLACK);
      HAL_Delay(1000);
      printf("fillCurve\r\n");
      tft->fillCurve(50, 100, 78, 38, 2, RA8875_WHITE);
    } else {
        printf("================  Text Mode =============\r\n");
      tft->displayOn(true);
      tft->GPIOX(true);      // Enable TFT - display enable tied to GPIOX
      tft->PWM1config(true, RA8875_PWM_CLK_DIV1024); // PWM output for backlight
      tft->PWM1out(255);
      printf("fillScreen\r\n");
      tft->fillScreen(RA8875_BLACK);
 
      /* Switch to text mode */
      tft->textMode();
      tft->cursorBlink(32);
 
 
      /* Set a solid for + bg color ... */
 
      /* ... or a fore color plus a transparent background */
 
 
      /* Set the cursor location (in pixels) */
      tft->textSetCursor(10, 10);
 
      /* Render some text! */
      printf("Render lots of Texts\r\n");
      char string[80] = "Hello, World! ";
      tft->textTransparent(RA8875_WHITE);
      tft->textWrite(string);
      HAL_Delay(500);
      tft->textColor(RA8875_WHITE, RA8875_RED);
      tft->textWrite(string);
      HAL_Delay(500);
      tft->textTransparent(RA8875_CYAN);
      tft->textWrite(string);
      HAL_Delay(500);
      tft->textTransparent(RA8875_GREEN);
      tft->textWrite(string);
      HAL_Delay(500);
      tft->textColor(RA8875_YELLOW, RA8875_CYAN);
      tft->textWrite(string);
      HAL_Delay(500);
      tft->textColor(RA8875_BLACK, RA8875_MAGENTA);
      tft->textWrite(string);
 
      HAL_Delay(1000);
 
      tft->textSetCursor(100, 100);
      tft->textEnlarge(1);
      tft->textTransparent(RA8875_YELLOW);
      tft->textWrite(string);
 
      tft->textSetCursor(100, 150);
      tft->textEnlarge(2);
      tft->textTransparent(RA8875_YELLOW);
      tft->textWrite(string);
 
      tft->textSetCursor(100, 200);
      tft->textEnlarge(3);
      tft->textTransparent(RA8875_YELLOW);
      tft->textWrite(string);
 
      tft->textSetCursor(100, 300);
      tft->textEnlarge(0);
      tft->textTransparent(RA8875_YELLOW);
      tft->textWrite(string);
    }
}
 
void initFRAM(SPI_HandleTypeDef *halSPI) {
    // nothrow: return nullptr on failure instead of throwing, then check it before use
    fram = new (std::nothrow) MB85RS64V(halSPI, MB85RS64_CS_GPIO_Port, MB85RS64_CS_Pin);
    if (fram == nullptr) {
        printf("MB85RS64V object could not be allocated (out of heap)\r\n");
        Error_Handler();
        return;
    }
 
    if (fram->begin()) {
        // begin() has already checked the ID once. Read it again to print it, and check that read too:
        // a transfer can complete without error and still return wrong bytes (seen once as 00 00 00 00),
        // so a mismatch is retried a few times before it is treated as a failure
        const uint8_t expectedId[MB85RS64V::ID_LENGTH] = { 0x04, 0x7F, 0x03, 0x02 };
        const int ID_READ_ATTEMPTS = 3;
        uint8_t id[MB85RS64V::ID_LENGTH] = { 0 };
 
        for (int attempt = 1; attempt <= ID_READ_ATTEMPTS; attempt++) {
            if (!fram->readId(id)) {
                printf("MB85RS64V ID read failed after begin() (HAL status %d), attempt %d of %d\r\n",
                        (int) fram->lastStatus(), attempt, ID_READ_ATTEMPTS);
            } else if (memcmp(id, expectedId, sizeof(expectedId)) != 0) {
                printf("MB85RS64V ID read gave %02X %02X %02X %02X (expected 04 7F 03 02), attempt %d of %d\r\n",
                        id[0], id[1], id[2], id[3], attempt, ID_READ_ATTEMPTS);
            } else {
                printf("MB85RS64V Found, ID: %02X %02X %02X %02X\r\n", id[0], id[1], id[2], id[3]);
                return;
            }
            HAL_Delay(10);
        }
        printf("MB85RS64V ID could not be read correctly after %d attempts\r\n", ID_READ_ATTEMPTS);
        Error_Handler();
        return;
    }
    printf("MB85RS64V not found (expected ID 04 7F 03 02): check HOLD/WP, CS (PB10) and power\r\n");
 
    // Show what the chip actually answered, to tell the likely causes apart:
    // FF FF FF FF = nothing driving MISO (no power, HOLD low, CS not wired), 00 00 00 00 = MISO held low
    uint8_t id[MB85RS64V::ID_LENGTH] = { 0 };
    const bool idRead = fram->readId(id);
    printf("  ID read %s, bytes: %02X %02X %02X %02X, last HAL status %d\r\n", idRead ? "OK" : "FAILED",
            id[0], id[1], id[2], id[3], (int) fram->lastStatus());
    printf("  SPI1: mode %s, polarity %s, phase %s, data size %s, NSS %s, prescaler 0x%02lX\r\n",
            halSPI->Init.Mode == SPI_MODE_MASTER ? "master" : "NOT master",
            halSPI->Init.CLKPolarity == SPI_POLARITY_LOW ? "low" : "high",
            halSPI->Init.CLKPhase == SPI_PHASE_1EDGE ? "1 edge" : "2 edge",
            halSPI->Init.DataSize == SPI_DATASIZE_8BIT ? "8-bit" : "NOT 8-bit",
            halSPI->Init.NSS == SPI_NSS_SOFT ? "soft" : "NOT soft",
            (unsigned long) halSPI->Init.BaudRatePrescaler);
 
    // RDSR does not depend on the chip supporting RDID: its bit 0 always reads 0, so FF means no answer at all,
    // while a value like 00 means the chip is alive and only the RDID command is the problem
    uint8_t status = 0xFF;
    const bool statusRead = fram->readStatus(&status);
    printf("  Status register read %s: %02X (FF = no answer, 00..8C = chip is answering)\r\n",
            statusRead ? "OK" : "FAILED", status);
    Error_Handler();
    return;
}
 
void testFRAM(void) {
    if (fram == nullptr) {
        printf("ERROR: testFRAM() called before a successful initFRAM()\r\n");
        Error_Handler();
        return;
    }
 
    uint8_t before[16];
    if (!fram->read(0x0000, before, sizeof(before))) {
        printf("FRAM read failed (HAL status %d)\r\n", (int) fram->lastStatus());
        Error_Handler();
        return;
    }
    printf("FRAM at 0x0000 before this boot:");
    for (size_t i = 0; i < sizeof(before); i++) {
        printf(" %02X", before[i]);
    }
    printf("\r\n");
 
    // The first byte counts boots; the rest is a fixed pattern
    uint8_t out[16] = { (uint8_t) (before[0] + 1), 0xA5, 0x5A, 0xFF, 0x00, 'M', 'C', 'T', 'F', 'R', 'A', 'M', 1, 2, 3, 4 };
    if (!fram->write(0x0000, out, sizeof(out))) {
        printf("FRAM write failed (HAL status %d)\r\n", (int) fram->lastStatus());
        Error_Handler();
        return;
    }
 
    uint8_t in[16] = { 0 };
    if (!fram->read(0x0000, in, sizeof(in))) {
        printf("FRAM read-back failed (HAL status %d)\r\n", (int) fram->lastStatus());
        Error_Handler();
        return;
    }
    printf("FRAM read back:                 ");
    for (size_t i = 0; i < sizeof(in); i++) {
        printf(" %02X", in[i]);
    }
    printf("\r\n");
 
    for (size_t i = 0; i < sizeof(out); i++) {
        if (in[i] != out[i]) {
            printf("FRAM read-back MISMATCH at byte %u\r\n", (unsigned) i);
            Error_Handler();
            return;
        }
    }
    printf("FRAM write/read-back OK, boot count %u\r\n", (unsigned) out[0]);
}
 
bool initTouchCalibration(void) {
    touchMatrixValid = false;
 
    if (tft == nullptr || fram == nullptr) {
        printf("ERROR: initTouchCalibration() needs initTest() and initFRAM() to have run first\r\n");
        Error_Handler();
        return false;
    }
 
    printf("Reading the stored touch calibration from the FRAM\r\n");
    touchCalibrationAttachStorage(tft, fram);
 
    if (!touchCalibrationLoad(tft, fram, &touchMatrix)) {
        // touchCalibrationLoad() has already printed the reason
        printf("No usable touch calibration in the FRAM: define TOUCH_CALIBRATION_ENABLE in main.h and calibrate\r\n");
        return false;
    }
 
    touchMatrixValid = true;
    printf("Touch calibration read from the FRAM: An=%ld Bn=%ld Cn=%ld Dn=%ld En=%ld Fn=%ld Divider=%ld\r\n",
            (long) touchMatrix.An, (long) touchMatrix.Bn, (long) touchMatrix.Cn, (long) touchMatrix.Dn,
            (long) touchMatrix.En, (long) touchMatrix.Fn, (long) touchMatrix.Divider);
    return true;
}
 
#ifdef TOUCH_CALIBRATION_ENABLE
void testTouch(UART_HandleTypeDef *huart) {
    const uint32_t DEMO_MS = 15000;     // how long the touch-to-draw demo runs
 
    if (tft == nullptr) {
        printf("ERROR: testTouch() called before initTest()\r\n");
        Error_Handler();
        return;
    }
 
    // begin() does not switch the display on; testLCD() does that, but it runs after this function,
    // so the display and its backlight must be enabled here before anything is drawn
    tft->displayOn(true);
    tft->GPIOX(true);      // Enable TFT - display enable tied to GPIOX
    tft->PWM1config(true, RA8875_PWM_CLK_DIV1024);
    tft->PWM1out(255);
 
    tft->touchEnable(true);
 
    if (huart == nullptr) {
        printf("ERROR: testTouch() needs the terminal UART handle\r\n");
        Error_Handler();
        return;
    }
 
    if (fram == nullptr) {
        printf("ERROR: testTouch() needs the FRAM: initFRAM() has not run\r\n");
        Error_Handler();
        return;
    }
    touchCalibrationAttachStorage(tft, fram);
 
    tsMatrix_t matrix;
 
    // Calibration mode always calibrates and overwrites whatever the FRAM holds
    if (!touchCalibrationRun(tft, huart, &matrix)) {
        printf("Touch calibration failed after repeated attempts\r\n");
        Error_Handler();
        return;
    }
    if (!touchCalibrationSave(tft, fram, &matrix)) {
        printf("Touch calibration could not be stored: the data read back from the FRAM differs\r\n");
        Error_Handler();
        return;
    }
    printf("Touch calibration stored in the FRAM\r\n");
    printf("Touch calibration done: An=%ld Bn=%ld Cn=%ld Dn=%ld En=%ld Fn=%ld Divider=%ld\r\n",
            (long) matrix.An, (long) matrix.Bn, (long) matrix.Cn, (long) matrix.Dn, (long) matrix.En,
            (long) matrix.Fn, (long) matrix.Divider);
 
    printf("Touch the screen: red dots follow your finger for %lu seconds\r\n", (unsigned long) (DEMO_MS / 1000));
    tft->fillScreen(RA8875_WHITE);
 
    const uint32_t start = HAL_GetTick();
    while ((HAL_GetTick() - start) < DEMO_MS) {
        if (tft->touched()) {
            uint16_t rx = 0;
            uint16_t ry = 0;
            tft->touchRead(&rx, &ry);
 
            tsPoint_t raw = { (int32_t) rx, (int32_t) ry };
            tsPoint_t pos = { 0, 0 };
            if (!touchCalibrationApply(&matrix, &raw, &pos)) {
                printf("Touch conversion failed (divider is zero)\r\n");
                Error_Handler();
                return;
            }
 
            printf("raw %u,%u -> screen %ld,%ld\r\n", (unsigned) rx, (unsigned) ry, (long) pos.x, (long) pos.y);
            if (pos.x >= 0 && pos.x < tft->width() && pos.y >= 0 && pos.y < tft->height()) {
                tft->fillCircle((int16_t) pos.x, (int16_t) pos.y, 4, RA8875_RED);
            }
        }
        HAL_Delay(5);
    }
}
#endif /* TOUCH_CALIBRATION_ENABLE */