TSC2046.cpp

/*
 * TSC2046.cpp
 *
 *  Created on: Sep 15, 2026
 *      Author: johng
 */
 
#include "TSC2046.hpp"
#include "STM32BusIORegister.hpp"
#include <cmath>
 
namespace {
 
// Multiplexer channel-select addresses, single-ended reference mode
// (temperature, VBAT, AUX -- everything except touch coordinates).
constexpr uint8_t kAddrSerTemp0 = 0b000;
constexpr uint8_t kAddrSerVBat  = 0b010;
constexpr uint8_t kAddrSerAux   = 0b110;
constexpr uint8_t kAddrSerTemp1 = 0b111;
 
// Multiplexer channel-select addresses, differential reference mode
// (touch coordinates only -- more accurate, not available for the others).
constexpr uint8_t kAddrDfrYPos  = 0b001;
constexpr uint8_t kAddrDfrZ1Pos = 0b011;
constexpr uint8_t kAddrDfrZ2Pos = 0b100;
constexpr uint8_t kAddrDfrXPos  = 0b101;
 
constexpr float kInternalVRef = 2.5f;
 
uint8_t buildControlByte(uint8_t channelSelect, bool singleEndedRef, bool enableInternalVRef, bool enableOrIdleADC) {
    uint8_t word = 0x80; // START, always 1
    word |= static_cast<uint8_t>((channelSelect & 0x07) << 4); // A2:A0
    // bit3 (MODE) left at 0: always 12-bit conversions.
    word |= singleEndedRef     ? (1u << 2) : 0; // SER/DFR'
    word |= enableInternalVRef ? (1u << 1) : 0; // PD1
    word |= enableOrIdleADC    ? (1u << 0) : 0; // PD0
    return word;
}
 
} // namespace
 
TSC2046::TSC2046(SPI_HandleTypeDef *hspi, GPIO_TypeDef *csPort, uint16_t csPin)
    : _spiDevice(hspi, csPort, csPin), _xPlateResistance(400), _vref(-1.f),
      _touchedThreshold(100000.f), _interruptsEnabled(true) {
}
 
void TSC2046::begin(uint32_t xPlateResistance) {
    _xPlateResistance = xPlateResistance;
    _spiDevice.begin();
}
 
void TSC2046::setVRef(float vref) {
    _vref = vref;
}
 
void TSC2046::setTouchedThreshold(float touchedThresholdOhms) {
    _touchedThreshold = touchedThresholdOhms;
}
 
float TSC2046::effectiveVRef() {
    return (_vref < 0.f) ? kInternalVRef : _vref;
}
 
uint16_t TSC2046::extractTwelveBitValue(uint32_t registerValue) {
    // The chip returns a 16-bit window: 1 leading null bit, then the 12-bit
    // conversion result, then 3 trailing zero bits -- shift off the
    // trailing padding and mask away the leading null bit.
    return static_cast<uint16_t>((registerValue >> 3) & 0xFFF);
}
 
uint16_t TSC2046::readCoord(uint8_t channelSelect) {
    bool enableInternalVRef;
    bool enableOrIdleADC;
 
    // NOTE (from the reference library): the datasheet says PD0=1 disables
    // interrupts, but empirically PENIRQ' still responds unless *both* PD1
    // and PD0 are high. Differential mode (used here) doesn't need VREF at
    // all, so PD1 is free to double up as the "disable interrupts" bit.
    if (_interruptsEnabled) {
        enableInternalVRef = false;
        enableOrIdleADC = false;
    } else {
        enableInternalVRef = true;
        enableOrIdleADC = true;
    }
 
    uint8_t controlByte = buildControlByte(channelSelect, /*singleEndedRef=*/false, enableInternalVRef, enableOrIdleADC);
 
    STM32BusIORegister controlReg(&_spiDevice, controlByte, /*width=*/2, /*addressWidth=*/1);
    return extractTwelveBitValue(controlReg.read());
}
 
uint16_t TSC2046::readExtra(uint8_t channelSelect) {
    bool enableInternalVRef = !(_vref > 0.f);
    bool enableOrIdleADC = !_interruptsEnabled;
 
    uint8_t controlByte = buildControlByte(channelSelect, /*singleEndedRef=*/true, enableInternalVRef, enableOrIdleADC);
 
    STM32BusIORegister controlReg(&_spiDevice, controlByte, /*width=*/2, /*addressWidth=*/1);
    return extractTwelveBitValue(controlReg.read());
}
 
TSC2046TouchPoint TSC2046::getPoint() {
    if (_interruptsEnabled) {
        __disable_irq();
    }
 
    int16_t xResult = static_cast<int16_t>(readCoord(kAddrDfrXPos));
    int16_t yResult = static_cast<int16_t>(readCoord(kAddrDfrYPos));
    int16_t z1Result = static_cast<int16_t>(readCoord(kAddrDfrZ1Pos));
    int16_t z2Result = static_cast<int16_t>(readCoord(kAddrDfrZ2Pos));
 
    if (_interruptsEnabled) {
        __enable_irq();
    }
 
    // R_TOUCH = R_X_PLATE * (X / 4096) * (Z2 / Z1 - 1)
    float pressure = _xPlateResistance * (xResult / 4096.f) *
                     ((static_cast<float>(z2Result) / static_cast<float>(z1Result)) - 1.f);
 
    TSC2046TouchPoint point;
    point.x = xResult;
    point.y = yResult;
    point.pressure = pressure;
    return point;
}
 
bool TSC2046::isTouched() {
    TSC2046TouchPoint point = getPoint();
    return std::isfinite(point.pressure) && point.pressure != 0.f && point.pressure < _touchedThreshold;
}
 
void TSC2046::enableInterrupts(bool enable) {
    _interruptsEnabled = enable;
    // Perform any read so the new PD bits actually reach the chip and take
    // effect (matches the reference library -- the PD bits only reach the
    // chip as a side effect of the next conversion command).
    readCoord(0);
}
 
float TSC2046::readTemperatureC() {
    return readTemperatureKelvin() - 273.f;
}
 
float TSC2046::readTemperatureF() {
    return (9.f / 5.f) * readTemperatureC() + 32.f;
}
 
float TSC2046::readTemperatureKelvin() {
    uint16_t temp0 = readExtra(kAddrSerTemp0);
    uint16_t temp1 = readExtra(kAddrSerTemp1);
 
    // V = (ADC_VALUE * VRef) / 4096; take the difference in millivolts, then
    // apply the datasheet's simplified T = 2.573 K/mV formula.
    float deltaMillivolts = ((static_cast<float>(temp1) - static_cast<float>(temp0)) * effectiveVRef() / 4096.f) * 1000.f;
    return deltaMillivolts * 2.573f;
}
 
float TSC2046::readBatteryVoltage() {
    constexpr float kVBatMultiplier = 4.f; // Datasheet: VBAT reading is divided by 4 internally.
    uint16_t rawVBat = readExtra(kAddrSerVBat);
    return (rawVBat * kVBatMultiplier * effectiveVRef()) / 4096.f;
}
 
float TSC2046::readAuxiliaryVoltage() {
    uint16_t rawVAux = readExtra(kAddrSerAux);
    return (rawVAux * effectiveVRef()) / 4096.f;
}