touch_cal.h

Go to the documentation of this file.

/*
 * SPDX-License-Identifier: LGPL-3.0-or-later
 * Copyright (c) 2026 Cryptnox SA
 */

 
#ifndef TOUCH_CAL_H
#define TOUCH_CAL_H
 
#include <stdbool.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif

typedef struct {
    uint16_t x_min;
    uint16_t x_max;
    uint16_t y_min;
    uint16_t y_max;
} touch_cal_t;

#define TOUCH_CAL_MIN_SPAN  500
#define TOUCH_CAL_RAW_MAX   4095
 
/* Extrapolating past a target that was tapped near the edge of the converter's
 * range lands outside it. Clamped rather than rejected: the tap itself was
 * fine, and a raw count the hardware can never report is simply an edge the
 * finger can never reach. Unsigned underflow is the reason this exists at all —
 * a -261 stored as 65275 inverts the axis. */
static inline uint16_t touch_cal_clamp(int32_t v)
{
    if (v < 0)                  { return 0U; }
    if (v > TOUCH_CAL_RAW_MAX)  { return (uint16_t)TOUCH_CAL_RAW_MAX; }
    return (uint16_t)v;
}
 
static inline bool touch_cal_from_corners(int16_t r0x, int16_t r0y,
                                          int16_t r1x, int16_t r1y,
                                          int16_t inset, int16_t w, int16_t h,
                                          touch_cal_t *out)
{
    const int32_t span_x = (int32_t)(w - 1 - inset) - (int32_t)inset;
    const int32_t span_y = (int32_t)(h - 1 - inset) - (int32_t)inset;
    const int32_t dx     = (int32_t)r1x - (int32_t)r0x;
    const int32_t dy     = (int32_t)r1y - (int32_t)r0y;
 
    if ((out == NULL) || (span_x <= 0) || (span_y <= 0)) { return false; }
    if ((dx < TOUCH_CAL_MIN_SPAN) || (dy < TOUCH_CAL_MIN_SPAN)) { return false; }
 
    out->x_min = touch_cal_clamp((int32_t)r0x - ((dx * inset) / span_x));
    out->x_max = touch_cal_clamp((int32_t)r1x + ((dx * inset) / span_x));
    out->y_min = touch_cal_clamp((int32_t)r0y - ((dy * inset) / span_y));
    out->y_max = touch_cal_clamp((int32_t)r1y + ((dy * inset) / span_y));
    return true;
}

#define TOUCH_JUMP_MAX_PX  25
 
/* How far z must rise above the lightest press of this touch to count as a
 * second contact. A knob, deliberately: z is contact area and force as much as
 * finger count, it differs between panels, and the only honest way to set it is
 * to watch the "second contact:" line ui.cpp logs under a real thumb. Too low
 * freezes hard taps, which costs nothing; too high lets the thumb through, which
 * is the bug. Err low.
 *
 * 30 because the bench said so: on the CYD this was written against, z idles
 * around 1900-2000 under one finger and a second contact stepped it 43% — which
 * the 50 this started at sat just above, and missed. */
#define TOUCH_Z_STEP_PCT   30

typedef struct {
    int16_t x;
    int16_t y;
    int16_t z_min;
    bool    have;
} touch_jump_t;
 
static inline bool touch_jump_second_contact(const touch_jump_t *st,
                                             int16_t z, int16_t x, int16_t y)
{
    const int32_t dx = (int32_t)x - (int32_t)st->x;
    const int32_t dy = (int32_t)y - (int32_t)st->y;
 
    if ((z > 0) && (st->z_min > 0)) {
        const int32_t step = (int32_t)st->z_min +
                             (((int32_t)st->z_min * TOUCH_Z_STEP_PCT) / 100);
        if ((int32_t)z > step) { return true; }
    }
    return ((dx * dx) + (dy * dy)) >
           ((int32_t)TOUCH_JUMP_MAX_PX * (int32_t)TOUCH_JUMP_MAX_PX);
}
 
static inline void touch_jump_filter(touch_jump_t *st, bool pressed,
                                     int16_t z, int16_t *x, int16_t *y)
{
    if (!pressed) { st->have = false; return; }
 
    if (st->have) {
        if (touch_jump_second_contact(st, z, *x, *y)) {
            *x = st->x;      /* hold the first finger's point */
            *y = st->y;
            return;
        }
        /* Track the lightest press, not the first: an operator who lands heavy
         * and eases off would otherwise set a bar their own thumb fits under. */
        if ((z > 0) && (z < st->z_min)) { st->z_min = z; }
    } else {
        st->z_min = z;
    }
 
    st->x    = *x;
    st->y    = *y;
    st->have = true;
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* TOUCH_CAL_H */