touchSelfTest.c

Go to the documentation of this file.

 
#include "main.h"
 
#ifdef TOUCH_SELFTEST_ENABLE
 
#include "touchSelfTest.h"
#include "entryPointCPP.hpp"
#include "touchZones.h"
#include "main.h"
#include <math.h>
#include <stdio.h>
#include <string.h>
 
extern SPI_HandleTypeDef hspi1;
 
/* Control bytes for the four touch conversions (START, channel, 12-bit, differential). */
static const uint8_t kControl[4]   = { 0xD0, 0x90, 0xB0, 0xC0 };
static const char *kControlName[4] = { "X", "Y", "Z1", "Z2" };
 
/* Idle test: number of samples and spacing. */
#define SELFTEST_IDLE_SAMPLES     25
#define SELFTEST_IDLE_SPACING_MS  10
 
/* Same touch criteria the main loop uses, so this test proves the loop won't fire when idle. */
#define SELFTEST_PRESSURE_MIN   40.0f
#define SELFTEST_PRESSURE_MAX   1500.0f
 
static touchSelfTestReport_t report;
 
static void resetReport(void) {
    memset(&report, 0, sizeof(report));
    report.passed = true;
    report.failedTest = TOUCH_SELFTEST_NONE;
}
 
static bool fail(touchSelfTestId_t id, const char *fmt, ...);
 
#include <stdarg.h>
static bool fail(touchSelfTestId_t id, const char *fmt, ...) {
    report.passed = false;
    report.failedTest = id;
    va_list args;
    va_start(args, fmt);
    vsnprintf(report.detail, sizeof(report.detail), fmt, args);
    va_end(args);
    return false;
}
 
static HAL_StatusTypeDef rawConversion(uint8_t cmd, uint8_t rx[3]) {
    uint8_t tx[3] = { cmd, 0x00, 0x00 };
    rx[0] = rx[1] = rx[2] = 0xAA; /* sentinel: shows if HAL never wrote rx */
    HAL_GPIO_WritePin(TSC2046_CS_GPIO_Port, TSC2046_CS_Pin, GPIO_PIN_RESET);
    HAL_StatusTypeDef st = HAL_SPI_TransmitReceive(&hspi1, tx, rx, 3, 100);
    HAL_GPIO_WritePin(TSC2046_CS_GPIO_Port, TSC2046_CS_Pin, GPIO_PIN_SET);
    return st;
}
 
/* Test 1: a raw HAL SPI transaction completes. */
static bool testSpiTransfer(void) {
    uint8_t rx[3];
    HAL_StatusTypeDef st = rawConversion(kControl[0], rx);
    if (st != HAL_OK) {
        return fail(TOUCH_SELFTEST_SPI_TRANSFER,
                "HAL SPI transfer failed (status %d, SPI error 0x%lX): check SPI1 setup and wiring",
                (int)st, (unsigned long)HAL_SPI_GetError(&hspi1));
    }
    return true;
}
 
/* Test 2: response framing is what a live TSC2046 returns; channels are not all identical. */
static bool testFraming(void) {
    uint16_t value[4];
    bool allIdentical = true;
 
    for (int i = 0; i < 4; i++) {
        uint8_t rx[3];
        if (rawConversion(kControl[i], rx) != HAL_OK) {
            return fail(TOUCH_SELFTEST_FRAMING, "SPI transfer failed reading %s", kControlName[i]);
        }
        /* Bit 7 of the first data byte is a leading null bit (always 0); the low 3 bits
         * of the last byte are trailing padding (always 0). A stuck-high MISO breaks this. */
        if ((rx[1] & 0x80) != 0 || (rx[2] & 0x07) != 0) {
            return fail(TOUCH_SELFTEST_FRAMING,
                    "%s response %02X %02X %02X is not a valid frame: MISO stuck or floating, check VCC and wiring",
                    kControlName[i], rx[0], rx[1], rx[2]);
        }
        value[i] = (uint16_t)((((uint16_t)rx[1] << 8) | rx[2]) >> 3) & 0xFFF;
        if (i > 0 && value[i] != value[0]) {
            allIdentical = false;
        }
    }
    if (allIdentical) {
        return fail(TOUCH_SELFTEST_FRAMING,
                "all four channels returned the same value (%u): MISO stuck low, chip not answering", value[0]);
    }
    return true;
}
 
/* NOTE: there is intentionally no temperature-sensor test here. The TSC2046's on-die
 * temperature reading (TSC2046::readTemperatureC()) is not accurate enough to give a
 * pass/fail limit -- it relies on a diode-difference measurement and a datasheet
 * approximation that has not been verified against a real thermometer on this hardware --
 * so a limit could fail a healthy board. "Is the chip answering" is covered by the
 * framing test above. See the file header in touchSelfTest.h. */
 
/* Test 3: with the panel untouched, no sample may look like a touch. */
static bool testIdle(void) {
    uint32_t phantom = 0;
 
    for (int i = 0; i < SELFTEST_IDLE_SAMPLES; i++) {
        int16_t x = 0, y = 0;
        float pressure = 0.0f;
        if (tsc2046GetPoint(&x, &y, &pressure)) {
            bool looksTouched = isfinite(pressure) && pressure >= SELFTEST_PRESSURE_MIN &&
                    pressure < SELFTEST_PRESSURE_MAX && touchZoneFromPoint(x, y) != TOUCH_ZONE_NONE;
            if (looksTouched) {
                phantom++;
            }
        }
        HAL_Delay(SELFTEST_IDLE_SPACING_MS);
    }
    report.idlePhantomTouches = phantom;
    if (phantom > 0) {
        return fail(TOUCH_SELFTEST_IDLE,
                "%lu of %d idle samples looked like touches: hands on the panel, panel pressed or shorted, or flex cable mis-seated",
                (unsigned long)phantom, SELFTEST_IDLE_SAMPLES);
    }
    return true;
}
 
const touchSelfTestReport_t *touchSelfTestRunAll(void) {
    resetReport();
 
    printf("Touch self-test (keep hands off the panel)...\r\n");
 
    if (!tsc2046IsReady()) {
        fail(TOUCH_SELFTEST_SPI_TRANSFER, "driver not ready: call initTSC2046() first");
        printf("  FAIL: %s\r\n", report.detail);
        return &report;
    }
 
    report.testsRun++;
    if (!testSpiTransfer()) { printf("  [1/3] SPI transfer ........ FAIL: %s\r\n", report.detail); goto done; }
    printf("  [1/3] SPI transfer ........ ok\r\n");
 
    report.testsRun++;
    if (!testFraming()) { printf("  [2/3] Response framing .... FAIL: %s\r\n", report.detail); goto done; }
    printf("  [2/3] Response framing .... ok\r\n");
 
    report.testsRun++;
    if (!testIdle()) { printf("  [3/3] Idle, no touches .... FAIL: %s\r\n", report.detail); goto done; }
    printf("  [3/3] Idle, no touches .... ok (%d samples)\r\n", SELFTEST_IDLE_SAMPLES);
 
done:
    printf("Self-test %s\r\n", report.passed ? "PASSED" : "FAILED (touch may not work; see above)");
    return &report;
}
 
const touchSelfTestReport_t *touchSelfTestGetReport(void) {
    return &report;
}
 
#endif /* TOUCH_SELFTEST_ENABLE */