touchCalibration.cpp

Go to the documentation of this file.

 
#include <stdio.h>
#include "main.h"
#include "touchCalibration.hpp"
 
#ifdef TOUCH_CALIBRATION_ENABLE
 
/* Defined in main.c, together with HAL_UART_RxCpltCallback() and HAL_UART_ErrorCallback() */
extern "C" {
extern volatile uint8_t uartRxChar;
extern volatile uint8_t uartKeyPressed;
}
 
namespace {
 
const int CALIBRATION_ATTEMPTS = 3;
 
const uint16_t TARGET_RADIUS = 5;
 
const uint32_t HOLD_MS = 300;
 
const uint32_t SETTLE_MS = 100;
 
const uint32_t RELEASE_GAP_MS = 100;
 
const uint16_t ACCEPTED_COLOUR = RA8875_GREEN;
 
void capturePress(Adafruit_RA8875 *display, uint16_t x, uint16_t y, uint16_t radius, tsPoint_t *point) {
    uint16_t rx = 0;
    uint16_t ry = 0;
 
    // Throw away anything left over from before, so an old touch is never used
    while (display->touched()) {
        display->touchRead(&rx, &ry);
        HAL_Delay(5);
    }
 
    for (;;) {
        // Wait for the pen to go down
        while (!display->touched()) {
            HAL_Delay(1);
        }
 
        const uint32_t pressStart = HAL_GetTick();
        uint32_t lastReading = pressStart;
        int64_t sumX = 0;
        int64_t sumY = 0;
        int32_t count = 0;
        bool accepted = false;
 
        // Read for as long as readings keep arriving
        while ((HAL_GetTick() - lastReading) < RELEASE_GAP_MS) {
            if (display->touched()) {
                display->touchRead(&rx, &ry);
                const uint32_t now = HAL_GetTick();
                lastReading = now;
                if ((rx != 0 || ry != 0) && (now - pressStart) >= SETTLE_MS) {
                    sumX += rx;
                    sumY += ry;
                    count++;
                }
                if (!accepted && (now - pressStart) >= HOLD_MS) {
                    accepted = true;
                    display->drawCircle(x, y, radius + 4, ACCEPTED_COLOUR);
                    display->drawCircle(x, y, radius + 5, ACCEPTED_COLOUR);
                }
            } else {
                HAL_Delay(1);
            }
        }
 
        if (accepted && count > 0) {
            point->x = (int32_t) (sumX / count);
            point->y = (int32_t) (sumY / count);
            return;
        }
        // A short tap, or no usable reading: ignore it and wait for a proper press
    }
}
 
const uint8_t KEY_ESC = 0x1B;
 
bool waitForSpaceOrEsc(UART_HandleTypeDef *uart) {
    uartKeyPressed = 0;
 
    // Cancel any receive left over from an earlier call and drop stale characters
    HAL_UART_AbortReceive(uart);
    __HAL_UART_FLUSH_DRREGISTER(uart);
 
    printf("  Press the space bar to show the next target, or Esc to redo this one\r\n");
 
    const HAL_StatusTypeDef status = HAL_UART_Receive_IT(uart, (uint8_t *) &uartRxChar, 1);
    if (status != HAL_OK) {
        printf("Could not start receiving from the UART (HAL status %d)\r\n", (int) status);
        Error_Handler();
        return true;
    }
 
    while (uartKeyPressed == 0) {
        HAL_Delay(1);
    }
    return uartKeyPressed != KEY_ESC;
}
 
tsPoint_t renderCalibrationScreen(Adafruit_RA8875 *display, uint16_t x, uint16_t y, uint16_t radius) {
    display->fillScreen(RA8875_WHITE);
    display->drawCircle(x, y, radius, RA8875_RED);
    display->drawCircle(x, y, radius + 2, 0x8410);  // 50% gray
 
    tsPoint_t point = { 0, 0 };
    capturePress(display, x, y, radius, &point);
    return point;
}
 
}   // namespace
 
bool touchCalibrationCompute(const tsPoint_t *display, const tsPoint_t *screen, tsMatrix_t *matrix) {
    if (display == nullptr || screen == nullptr || matrix == nullptr) {
        return false;
    }
 
    matrix->Divider = ((screen[0].x - screen[2].x) * (screen[1].y - screen[2].y)) -
            ((screen[1].x - screen[2].x) * (screen[0].y - screen[2].y));
 
    if (matrix->Divider == 0) {
        return false;
    }
 
    matrix->An = ((display[0].x - display[2].x) * (screen[1].y - screen[2].y)) -
            ((display[1].x - display[2].x) * (screen[0].y - screen[2].y));
 
    matrix->Bn = ((screen[0].x - screen[2].x) * (display[1].x - display[2].x)) -
            ((display[0].x - display[2].x) * (screen[1].x - screen[2].x));
 
    matrix->Cn = (screen[2].x * display[1].x - screen[1].x * display[2].x) * screen[0].y +
            (screen[0].x * display[2].x - screen[2].x * display[0].x) * screen[1].y +
            (screen[1].x * display[0].x - screen[0].x * display[1].x) * screen[2].y;
 
    matrix->Dn = ((display[0].y - display[2].y) * (screen[1].y - screen[2].y)) -
            ((display[1].y - display[2].y) * (screen[0].y - screen[2].y));
 
    matrix->En = ((screen[0].x - screen[2].x) * (display[1].y - display[2].y)) -
            ((display[0].y - display[2].y) * (screen[1].x - screen[2].x));
 
    matrix->Fn = (screen[2].x * display[1].y - screen[1].x * display[2].y) * screen[0].y +
            (screen[0].x * display[2].y - screen[2].x * display[0].y) * screen[1].y +
            (screen[1].x * display[0].y - screen[0].x * display[1].y) * screen[2].y;
 
    return true;
}
 
bool touchCalibrationApply(const tsMatrix_t *matrix, const tsPoint_t *raw, tsPoint_t *display) {
    if (matrix == nullptr || raw == nullptr || display == nullptr || matrix->Divider == 0) {
        return false;
    }
 
    display->x = ((matrix->An * raw->x) + (matrix->Bn * raw->y) + matrix->Cn) / matrix->Divider;
    display->y = ((matrix->Dn * raw->x) + (matrix->En * raw->y) + matrix->Fn) / matrix->Divider;
    return true;
}
 
bool touchCalibrationRun(Adafruit_RA8875 *display, UART_HandleTypeDef *uart, tsMatrix_t *matrix) {
    if (display == nullptr || uart == nullptr || matrix == nullptr) {
        return false;
    }
 
    const int32_t w = display->width();
    const int32_t h = display->height();
 
    // Three targets: 10% over and 10% down, 50% over and 90% down, 90% over and 50% down
    tsPoint_t displayPoints[3] = { { w / 10, h / 10 }, { w / 2, h - h / 10 }, { w - w / 10, h / 2 } };
    tsPoint_t touchPoints[3];
 
    for (int attempt = 1; attempt <= CALIBRATION_ATTEMPTS; attempt++) {
        printf("Touch calibration, attempt %d of %d\r\n", attempt, CALIBRATION_ATTEMPTS);
 
        for (int i = 0; i < 3; i++) {
            touchPoints[i] = renderCalibrationScreen(display, (uint16_t) displayPoints[i].x,
                    (uint16_t) displayPoints[i].y, TARGET_RADIUS);
            printf("  point %d: display %ld,%ld  raw %ld,%ld\r\n", i + 1, (long) displayPoints[i].x,
                    (long) displayPoints[i].y, (long) touchPoints[i].x, (long) touchPoints[i].y);
            if (i < 2 && !waitForSpaceOrEsc(uart)) {
                // Esc: throw this touch away and show the same target again
                printf("  point %d discarded, touch it again\r\n", i + 1);
                i--;
            }
        }
 
        display->fillScreen(RA8875_WHITE);
 
        if (touchCalibrationCompute(displayPoints, touchPoints, matrix)) {
            return true;
        }
        printf("  the three touches lie on one line, calibration is not usable\r\n");
    }
    return false;
}
 
#endif /* TOUCH_CALIBRATION_ENABLE */