diff --git a/Marlin/src/HAL/LPC1768/tft/xpt2046.cpp b/Marlin/src/HAL/LPC1768/tft/xpt2046.cpp
index 6c00a4cae0b..a737266c681 100644
--- a/Marlin/src/HAL/LPC1768/tft/xpt2046.cpp
+++ b/Marlin/src/HAL/LPC1768/tft/xpt2046.cpp
@@ -78,7 +78,7 @@ bool XPT2046::getRawPoint(int16_t * const x, int16_t * const y) {
if (isBusy() || !isTouched()) return false;
*x = getRawData(XPT2046_X);
*y = getRawData(XPT2046_Y);
- return true;
+ return isTouched();
}
uint16_t XPT2046::getRawData(const XPTCoordinate coordinate) {
diff --git a/Marlin/src/HAL/STM32/tft/xpt2046.cpp b/Marlin/src/HAL/STM32/tft/xpt2046.cpp
index 57c50653c9c..c5645ad79c4 100644
--- a/Marlin/src/HAL/STM32/tft/xpt2046.cpp
+++ b/Marlin/src/HAL/STM32/tft/xpt2046.cpp
@@ -123,7 +123,7 @@ bool XPT2046::getRawPoint(int16_t * const x, int16_t * const y) {
if (isBusy() || !isTouched()) return false;
*x = getRawData(XPT2046_X);
*y = getRawData(XPT2046_Y);
- return true;
+ return isTouched();
}
uint16_t XPT2046::getRawData(const XPTCoordinate coordinate) {
diff --git a/Marlin/src/HAL/STM32F1/tft/xpt2046.cpp b/Marlin/src/HAL/STM32F1/tft/xpt2046.cpp
index 3428110c127..475290de45b 100644
--- a/Marlin/src/HAL/STM32F1/tft/xpt2046.cpp
+++ b/Marlin/src/HAL/STM32F1/tft/xpt2046.cpp
@@ -90,7 +90,7 @@ bool XPT2046::getRawPoint(int16_t * const x, int16_t * const y) {
if (isBusy() || !isTouched()) return false;
*x = getRawData(XPT2046_X);
*y = getRawData(XPT2046_Y);
- return true;
+ return isTouched();
}
uint16_t XPT2046::getRawData(const XPTCoordinate coordinate) {
diff --git a/Marlin/src/lcd/e3v2/jyersui/dwin.cpp b/Marlin/src/lcd/e3v2/jyersui/dwin.cpp
index 6e7898a389f..be8605e3bba 100644
--- a/Marlin/src/lcd/e3v2/jyersui/dwin.cpp
+++ b/Marlin/src/lcd/e3v2/jyersui/dwin.cpp
@@ -389,9 +389,9 @@ private:
// Draw value text on
if (viewer_print_value) {
- xy_uint_t offset { 0, cell_height_px / 2 - 6 };
+ const int8_t offset_y = cell_height_px / 2 - 6;
if (isnan(bedlevel.z_values[x][y])) { // undefined
- dwinDrawString(false, font6x12, COLOR_WHITE, COLOR_BG_BLUE, start_x_px + cell_width_px / 2 - 5, start_y_px + offset.y, F("X"));
+ dwinDrawString(false, font6x12, COLOR_WHITE, COLOR_BG_BLUE, start_x_px + cell_width_px / 2 - 5, start_y_px + offset_y, F("X"));
}
else { // has value
MString<12> msg;
@@ -399,10 +399,10 @@ private:
msg.set(p_float_t(abs(bedlevel.z_values[x][y]), 2));
else
msg.setf(F("%02i"), uint16_t(abs(bedlevel.z_values[x][y] - int16_t(bedlevel.z_values[x][y])) * 100));
- offset.x = cell_width_px / 2 - 3 * msg.length() - 2;
+ const int8_t offset_x = cell_width_px / 2 - 3 * msg.length() - 2;
if (GRID_MAX_POINTS_X >= 10)
- dwinDrawString(false, font6x12, COLOR_WHITE, COLOR_BG_BLUE, start_x_px - 2 + offset.x, start_y_px + offset.y /*+ square / 2 - 6*/, F("."));
- dwinDrawString(false, font6x12, COLOR_WHITE, COLOR_BG_BLUE, start_x_px + 1 + offset.x, start_y_px + offset.y /*+ square / 2 - 6*/, msg);
+ dwinDrawString(false, font6x12, COLOR_WHITE, COLOR_BG_BLUE, start_x_px - 2 + offset_x, start_y_px + offset_y /*+ square / 2 - 6*/, F("."));
+ dwinDrawString(false, font6x12, COLOR_WHITE, COLOR_BG_BLUE, start_x_px + 1 + offset_x, start_y_px + offset_y /*+ square / 2 - 6*/, msg);
}
safe_delay(10);
LCD_SERIAL.flushTX();
diff --git a/Marlin/src/lcd/e3v2/proui/bedlevel_tools.cpp b/Marlin/src/lcd/e3v2/proui/bedlevel_tools.cpp
index f2fe008667c..64d145c95df 100644
--- a/Marlin/src/lcd/e3v2/proui/bedlevel_tools.cpp
+++ b/Marlin/src/lcd/e3v2/proui/bedlevel_tools.cpp
@@ -247,9 +247,9 @@ bool BedLevelTools::meshValidate() {
// Draw value text on
const uint8_t fs = DWINUI::fontWidth(meshfont);
if (viewer_print_value) {
- xy_uint_t offset { 0, cell_height_px / 2 - fs };
+ const int8_t offset_y = cell_height_px / 2 - fs;
if (isnan(bedlevel.z_values[x][y])) { // undefined
- dwinDrawString(false, meshfont, COLOR_WHITE, COLOR_BG_BLUE, start_x_px + cell_width_px / 2 - 5, start_y_px + offset.y, F("X"));
+ dwinDrawString(false, meshfont, COLOR_WHITE, COLOR_BG_BLUE, start_x_px + cell_width_px / 2 - 5, start_y_px + offset_y, F("X"));
}
else { // has value
MString<12> msg;
@@ -257,10 +257,10 @@ bool BedLevelTools::meshValidate() {
msg.set(p_float_t(abs(bedlevel.z_values[x][y]), 2));
else
msg.setf(F("%02i"), uint16_t(abs(bedlevel.z_values[x][y] - int16_t(bedlevel.z_values[x][y])) * 100));
- offset.x = cell_width_px / 2 - (fs / 2) * msg.length() - 2;
+ const int8_t offset_x = cell_width_px / 2 - (fs / 2) * msg.length() - 2;
if ((GRID_MAX_POINTS_X) >= TERN(TJC_DISPLAY, 8, 10))
- dwinDrawString(false, meshfont, COLOR_WHITE, COLOR_BG_BLUE, start_x_px - 2 + offset.x, start_y_px + offset.y, F("."));
- dwinDrawString(false, meshfont, COLOR_WHITE, COLOR_BG_BLUE, start_x_px + 1 + offset.x, start_y_px + offset.y, msg);
+ dwinDrawString(false, meshfont, COLOR_WHITE, COLOR_BG_BLUE, start_x_px - 2 + offset_x, start_y_px + offset_y, F("."));
+ dwinDrawString(false, meshfont, COLOR_WHITE, COLOR_BG_BLUE, start_x_px + 1 + offset_x, start_y_px + offset_y, msg);
}
safe_delay(10);
LCD_SERIAL.flushTX();
diff --git a/Marlin/src/lcd/extui/mks_ui/tft_lvgl_configuration.cpp b/Marlin/src/lcd/extui/mks_ui/tft_lvgl_configuration.cpp
index 7adce94c2fa..ba898162d1f 100644
--- a/Marlin/src/lcd/extui/mks_ui/tft_lvgl_configuration.cpp
+++ b/Marlin/src/lcd/extui/mks_ui/tft_lvgl_configuration.cpp
@@ -305,35 +305,28 @@ uint16_t getTickDiff(const uint16_t curTick, const uint16_t lastTick) {
return (TICK_CYCLE) * (lastTick <= curTick ? (curTick - lastTick) : (0xFFFFFFFF - lastTick + curTick));
}
-static bool get_point(xy_int_t &point) {
- if (!touch.getRawPoint(&point.x, &point.y)) return false;
+static bool get_point(int16_t * const x, int16_t * const y) {
+ if (!touch.getRawPoint(x, y)) return false;
#if ENABLED(TOUCH_SCREEN_CALIBRATION)
const calibrationState state = touch_calibration.get_calibration_state();
if (WITHIN(state, CALIBRATION_TOP_LEFT, CALIBRATION_BOTTOM_LEFT)) {
- if (touch_calibration.handleTouch(point)) lv_update_touch_calibration_screen();
+ if (touch_calibration.handleTouch(*x, *y)) lv_update_touch_calibration_screen();
return false;
}
#endif
- point.x = int16_t((int32_t(point.x) * _TOUCH_CALIBRATION_X) >> 16) + _TOUCH_OFFSET_X;
- point.y = int16_t((int32_t(point.y) * _TOUCH_CALIBRATION_Y) >> 16) + _TOUCH_OFFSET_Y;
+ *x = int16_t((int32_t(*x) * _TOUCH_CALIBRATION_X) >> 16) + _TOUCH_OFFSET_X;
+ *y = int16_t((int32_t(*y) * _TOUCH_CALIBRATION_Y) >> 16) + _TOUCH_OFFSET_Y;
return true;
}
bool my_touchpad_read(lv_indev_drv_t * indev_driver, lv_indev_data_t * data) {
static xy_int_t last { 0, 0 };
- if (get_point(last)) {
- data->point.x = (TFT_ROTATION == TFT_ROTATE_180) ? TFT_WIDTH - last.x : last.x;
- data->point.y = (TFT_ROTATION == TFT_ROTATE_180) ? TFT_HEIGHT - last.y : last.y;
- data->state = LV_INDEV_STATE_PR;
- }
- else {
- data->point.x = (TFT_ROTATION == TFT_ROTATE_180) ? TFT_WIDTH - last.x : last.x;
- data->point.y = (TFT_ROTATION == TFT_ROTATE_180) ? TFT_HEIGHT - last.y : last.y;
- data->state = LV_INDEV_STATE_REL;
- }
+ data->state = get_point(&last.x, &last.y) ? LV_INDEV_STATE_PR : LV_INDEV_STATE_REL;
+ data->point.x = (TFT_ROTATION == TFT_ROTATE_180) ? TFT_WIDTH - last.x : last.x;
+ data->point.y = (TFT_ROTATION == TFT_ROTATE_180) ? TFT_HEIGHT - last.y : last.y;
return false; // Return `false` since no data is buffering or left to read
}
diff --git a/Marlin/src/lcd/tft/touch.cpp b/Marlin/src/lcd/tft/touch.cpp
index 8e79e397ade..3c0b21ba8fd 100644
--- a/Marlin/src/lcd/tft/touch.cpp
+++ b/Marlin/src/lcd/tft/touch.cpp
@@ -39,7 +39,7 @@
#include "tft.h"
bool Touch::enabled = true;
-xy_int_t Touch::point;
+int16_t Touch::x, Touch::y;
touch_control_t Touch::controls[];
touch_control_t *Touch::current_control;
uint16_t Touch::controls_count;
@@ -67,13 +67,17 @@ void Touch::add_control(TouchControlType type, uint16_t x, uint16_t y, uint16_t
if (controls_count == MAX_CONTROLS) return;
controls[controls_count].type = type;
- controls[controls_count].pos.set(x, y);
- controls[controls_count].size.set(width, height);
+ controls[controls_count].x = x;
+ controls[controls_count].y = y;
+ controls[controls_count].width = width;
+ controls[controls_count].height = height;
controls[controls_count].data = data;
controls_count++;
}
void Touch::idle() {
+ int16_t _x, _y;
+
if (!enabled) return;
// Return if Touch::idle is called within the same millisecond
@@ -81,8 +85,7 @@ void Touch::idle() {
if (now <= next_touch_ms) return;
next_touch_ms = now;
- xy_int_t got_point;
- if (get_point(got_point)) {
+ if (get_point(&_x, &_y)) {
#if HAS_RESUME_CONTINUE
// UI is waiting for a click anywhere?
if (wait_for_user) {
@@ -106,13 +109,11 @@ void Touch::idle() {
if (time_to_hold == 0) time_to_hold = now + MINIMUM_HOLD_TIME;
if (PENDING(now, time_to_hold)) return;
- if (bool(point)) {
+ if (x != 0 && y != 0) {
if (current_control) {
- if ( WITHIN(point.x, current_control->pos.x - FREE_MOVE_RANGE, current_control->pos.x + current_control->size.x + FREE_MOVE_RANGE)
- && WITHIN(point.y, current_control->pos.y - FREE_MOVE_RANGE, current_control->pos.y + current_control->size.y + FREE_MOVE_RANGE)
- ) {
- LIMIT(point.x, current_control->pos.x, current_control->pos.x + current_control->size.x);
- LIMIT(point.y, current_control->pos.y, current_control->pos.y + current_control->size.y);
+ if (WITHIN(x, current_control->x - FREE_MOVE_RANGE, current_control->x + current_control->width + FREE_MOVE_RANGE) && WITHIN(y, current_control->y - FREE_MOVE_RANGE, current_control->y + current_control->height + FREE_MOVE_RANGE)) {
+ LIMIT(x, current_control->x, current_control->x + current_control->width);
+ LIMIT(y, current_control->y, current_control->y + current_control->height);
touch(current_control);
}
else
@@ -120,10 +121,7 @@ void Touch::idle() {
}
else {
for (uint16_t i = 0; i < controls_count; i++) {
- if (TERN0(TOUCH_SCREEN_CALIBRATION, controls[i].type == CALIBRATE)
- || ( WITHIN(point.x, controls[i].pos.x, controls[i].pos.x + controls[i].size.x)
- && WITHIN(point.y, controls[i].pos.y, controls[i].pos.y + controls[i].size.y))
- ) {
+ if ((WITHIN(x, controls[i].x, controls[i].x + controls[i].width) && WITHIN(y, controls[i].y, controls[i].y + controls[i].height)) || (TERN(TOUCH_SCREEN_CALIBRATION, controls[i].type == CALIBRATE, false))) {
touch_control_type = controls[i].type;
touch(&controls[i]);
break;
@@ -134,10 +132,11 @@ void Touch::idle() {
if (!current_control)
touch_time = now;
}
- point = got_point;
+ x = _x;
+ y = _y;
}
else {
- point.reset();
+ x = y = 0;
current_control = nullptr;
touch_time = 0;
touch_control_type = NONE;
@@ -150,7 +149,7 @@ void Touch::touch(touch_control_t *control) {
switch (control->type) {
#if ENABLED(TOUCH_SCREEN_CALIBRATION)
case CALIBRATE:
- if (touch_calibration.handleTouch(point)) ui.refresh();
+ if (touch_calibration.handleTouch(x, y)) ui.refresh();
break;
#endif
@@ -177,7 +176,7 @@ void Touch::touch(touch_control_t *control) {
ui.encoderPosition = ui.encoderPosition + LCD_HEIGHT < (uint32_t)screen_items ? ui.encoderPosition + LCD_HEIGHT : screen_items;
ui.refresh();
break;
- case SLIDER: hold(control); ui.encoderPosition = (point.x - control->pos.x) * control->data / control->size.x; break;
+ case SLIDER: hold(control); ui.encoderPosition = (x - control->x) * control->data / control->width; break;
case INCREASE: hold(control, repeat_delay - 5); TERN(AUTO_BED_LEVELING_UBL, ui.external_control ? bedlevel.encoder_diff++ : ui.encoderPosition++, ui.encoderPosition++); break;
case DECREASE: hold(control, repeat_delay - 5); TERN(AUTO_BED_LEVELING_UBL, ui.external_control ? bedlevel.encoder_diff-- : ui.encoderPosition--, ui.encoderPosition--); break;
case HEATER:
@@ -263,16 +262,19 @@ void Touch::hold(touch_control_t *control, millis_t delay) {
ui.refresh();
}
-bool Touch::get_point(xy_int_t &point) {
- bool is_touched = false;
+bool Touch::get_point(int16_t * const x, int16_t * const y) {
#if ANY(TFT_TOUCH_DEVICE_XPT2046, TFT_TOUCH_DEVICE_GT911)
- is_touched = (TOUCH_ORIENTATION_NONE != _TOUCH_ORIENTATION)
- && (TOUCH_PORTRAIT == _TOUCH_ORIENTATION
- ? io.getRawPoint(&point.y, &point.x)
- : io.getRawPoint(&point.x, &point.y));
- #if ENABLED(TFT_TOUCH_DEVICE_XPT2046)
- point.x = uint16_t((uint32_t(point.x) * _TOUCH_CALIBRATION_X) >> 16) + _TOUCH_OFFSET_X;
- point.y = uint16_t((uint32_t(point.y) * _TOUCH_CALIBRATION_Y) >> 16) + _TOUCH_OFFSET_Y;
+ const bool is_touched = TOUCH_PORTRAIT == _TOUCH_ORIENTATION ? io.getRawPoint(y, x) : io.getRawPoint(x, y);
+ #endif
+ #if ENABLED(TFT_TOUCH_DEVICE_XPT2046)
+ #if ENABLED(TOUCH_SCREEN_CALIBRATION)
+ if (is_touched && TOUCH_ORIENTATION_NONE != _TOUCH_ORIENTATION) {
+ *x = int16_t((int32_t(*x) * _TOUCH_CALIBRATION_X) >> 16) + _TOUCH_OFFSET_X;
+ *y = int16_t((int32_t(*y) * _TOUCH_CALIBRATION_Y) >> 16) + _TOUCH_OFFSET_Y;
+ }
+ #else
+ *x = uint16_t((uint32_t(*x) * _TOUCH_CALIBRATION_X) >> 16) + _TOUCH_OFFSET_X;
+ *y = uint16_t((uint32_t(*y) * _TOUCH_CALIBRATION_Y) >> 16) + _TOUCH_OFFSET_Y;
#endif
#endif
diff --git a/Marlin/src/lcd/tft/touch.h b/Marlin/src/lcd/tft/touch.h
index 6c0ff88f467..93f9327a15b 100644
--- a/Marlin/src/lcd/tft/touch.h
+++ b/Marlin/src/lcd/tft/touch.h
@@ -57,8 +57,10 @@ enum TouchControlType : uint16_t {
typedef struct __attribute__((__packed__)) {
TouchControlType type;
- xy_uint_t pos;
- xy_uint_t size;
+ uint16_t x;
+ uint16_t y;
+ uint16_t width;
+ uint16_t height;
intptr_t data;
} touch_control_t;
@@ -75,7 +77,7 @@ typedef struct __attribute__((__packed__)) {
class Touch {
private:
static TOUCH_DRIVER_CLASS io;
- static xy_int_t point;
+ static int16_t x, y;
static bool enabled;
static touch_control_t controls[MAX_CONTROLS];
@@ -85,7 +87,7 @@ class Touch {
static millis_t next_touch_ms, time_to_hold, repeat_delay, touch_time;
static TouchControlType touch_control_type;
- static bool get_point(xy_int_t &point);
+ static bool get_point(int16_t * const x, int16_t * const y);
static void touch(touch_control_t *control);
static void hold(touch_control_t *control, millis_t delay=0);
diff --git a/Marlin/src/lcd/tft_io/touch_calibration.cpp b/Marlin/src/lcd/tft_io/touch_calibration.cpp
index b1cdfe6cda9..f76c29eb49f 100644
--- a/Marlin/src/lcd/tft_io/touch_calibration.cpp
+++ b/Marlin/src/lcd/tft_io/touch_calibration.cpp
@@ -58,18 +58,18 @@ void TouchCalibration::validate_calibration() {
#define CP(N) calibration_points[CALIBRATION_##N]
if (landscape) {
calibration_state = CALIBRATION_SUCCESS;
- calibration.x = ((CP(TOP_RIGHT).x - CP(TOP_LEFT).x) << 17) / (CP(BOTTOM_RIGHT).raw.x + CP(TOP_RIGHT).raw.x - CP(BOTTOM_LEFT).raw.x - CP(TOP_LEFT).raw.x);
- calibration.y = ((CP(BOTTOM_LEFT).y - CP(TOP_LEFT).y) << 17) / (CP(BOTTOM_RIGHT).raw.y - CP(TOP_RIGHT).raw.y + CP(BOTTOM_LEFT).raw.y - CP(TOP_LEFT).raw.y);
- calibration.offset.x = CP(TOP_LEFT).x - int16_t(((CP(TOP_LEFT).raw.x + CP(BOTTOM_LEFT).raw.x) * calibration.x) >> 17);
- calibration.offset.y = CP(TOP_LEFT).y - int16_t(((CP(TOP_LEFT).raw.y + CP(TOP_RIGHT).raw.y) * calibration.y) >> 17);
+ calibration.x = ((CP(TOP_RIGHT).x - CP(TOP_LEFT).x) << 17) / (CP(BOTTOM_RIGHT).raw_x + CP(TOP_RIGHT).raw_x - CP(BOTTOM_LEFT).raw_x - CP(TOP_LEFT).raw_x);
+ calibration.y = ((CP(BOTTOM_LEFT).y - CP(TOP_LEFT).y) << 17) / (CP(BOTTOM_RIGHT).raw_y - CP(TOP_RIGHT).raw_y + CP(BOTTOM_LEFT).raw_y - CP(TOP_LEFT).raw_y);
+ calibration.offset_x = CP(TOP_LEFT).x - int16_t(((CP(TOP_LEFT).raw_x + CP(BOTTOM_LEFT).raw_x) * calibration.x) >> 17);
+ calibration.offset_y = CP(TOP_LEFT).y - int16_t(((CP(TOP_LEFT).raw_y + CP(TOP_RIGHT).raw_y) * calibration.y) >> 17);
calibration.orientation = TOUCH_LANDSCAPE;
}
else if (portrait) {
calibration_state = CALIBRATION_SUCCESS;
- calibration.x = ((CP(TOP_RIGHT).x - CP(TOP_LEFT).x) << 17) / (CP(BOTTOM_RIGHT).raw.y + CP(TOP_RIGHT).raw.y - CP(BOTTOM_LEFT).raw.y - CP(TOP_LEFT).raw.y);
- calibration.y = ((CP(BOTTOM_LEFT).y - CP(TOP_LEFT).y) << 17) / (CP(BOTTOM_RIGHT).raw.x - CP(TOP_RIGHT).raw.x + CP(BOTTOM_LEFT).raw.x - CP(TOP_LEFT).raw.x);
- calibration.offset.x = CP(TOP_LEFT).x - int16_t(((CP(TOP_LEFT).raw.y + CP(BOTTOM_LEFT).raw.y) * calibration.x) >> 17);
- calibration.offset.y = CP(TOP_LEFT).y - int16_t(((CP(TOP_LEFT).raw.x + CP(TOP_RIGHT).raw.x) * calibration.y) >> 17);
+ calibration.x = ((CP(TOP_RIGHT).x - CP(TOP_LEFT).x) << 17) / (CP(BOTTOM_RIGHT).raw_y + CP(TOP_RIGHT).raw_y - CP(BOTTOM_LEFT).raw_y - CP(TOP_LEFT).raw_y);
+ calibration.y = ((CP(BOTTOM_LEFT).y - CP(TOP_LEFT).y) << 17) / (CP(BOTTOM_RIGHT).raw_x - CP(TOP_RIGHT).raw_x + CP(BOTTOM_LEFT).raw_x - CP(TOP_LEFT).raw_x);
+ calibration.offset_x = CP(TOP_LEFT).x - int16_t(((CP(TOP_LEFT).raw_y + CP(BOTTOM_LEFT).raw_y) * calibration.x) >> 17);
+ calibration.offset_y = CP(TOP_LEFT).y - int16_t(((CP(TOP_LEFT).raw_x + CP(TOP_RIGHT).raw_x) * calibration.y) >> 17);
calibration.orientation = TOUCH_PORTRAIT;
}
else {
@@ -83,23 +83,23 @@ void TouchCalibration::validate_calibration() {
SERIAL_ECHOLNPGM("Touch screen calibration completed");
SERIAL_ECHOLN(F("#define TOUCH_"), F("CALIBRATION_X "), calibration.x);
SERIAL_ECHOLN(F("#define TOUCH_"), F("CALIBRATION_Y "), calibration.y);
- SERIAL_ECHOLN(F("#define TOUCH_"), F("OFFSET_X "), calibration.offset.x);
- SERIAL_ECHOLN(F("#define TOUCH_"), F("OFFSET_Y "), calibration.offset.y);
+ SERIAL_ECHOLN(F("#define TOUCH_"), F("OFFSET_X "), calibration.offset_x);
+ SERIAL_ECHOLN(F("#define TOUCH_"), F("OFFSET_Y "), calibration.offset_y);
SERIAL_ECHO(F("#define TOUCH_")); SERIAL_ECHO_TERNARY(calibration.orientation == TOUCH_LANDSCAPE, "ORIENTATION ", "TOUCH_LANDSCAPE", "TOUCH_PORTRAIT", "\n");
TERN_(TOUCH_CALIBRATION_AUTO_SAVE, settings.save());
}
}
-bool TouchCalibration::handleTouch(const xy_int_t &point) {
+bool TouchCalibration::handleTouch(const uint16_t x, const uint16_t y) {
const millis_t now = millis();
+
if (next_touch_update_ms && PENDING(now, next_touch_update_ms)) return false;
next_touch_update_ms = now + BUTTON_DELAY_MENU;
if (calibration_state < CALIBRATION_SUCCESS) {
- calibration_points[calibration_state].raw = point;
- DEBUG_ECHOLNPGM("TouchCalibration - State: ", calibration_state,
- ", x: ", calibration_points[calibration_state].x, ", raw.x: ", point.x,
- ", y: ", calibration_points[calibration_state].y, ", raw.y: ", point.y);
+ calibration_points[calibration_state].raw_x = x;
+ calibration_points[calibration_state].raw_y = y;
+ DEBUG_ECHOLNPGM("TouchCalibration - State: ", calibration_state, ", x: ", calibration_points[calibration_state].x, ", raw_x: ", x, ", y: ", calibration_points[calibration_state].y, ", raw_y: ", y);
}
switch (calibration_state) {
diff --git a/Marlin/src/lcd/tft_io/touch_calibration.h b/Marlin/src/lcd/tft_io/touch_calibration.h
index be226db224c..5e15f85cb57 100644
--- a/Marlin/src/lcd/tft_io/touch_calibration.h
+++ b/Marlin/src/lcd/tft_io/touch_calibration.h
@@ -27,8 +27,8 @@
#define _TOUCH_CALIBRATION_X touch_calibration.calibration.x
#define _TOUCH_CALIBRATION_Y touch_calibration.calibration.y
-#define _TOUCH_OFFSET_X touch_calibration.calibration.offset.x
-#define _TOUCH_OFFSET_Y touch_calibration.calibration.offset.y
+#define _TOUCH_OFFSET_X touch_calibration.calibration.offset_x
+#define _TOUCH_OFFSET_Y touch_calibration.calibration.offset_y
#define _TOUCH_ORIENTATION touch_calibration.calibration.orientation
#ifndef TOUCH_SCREEN_CALIBRATION_PRECISION
@@ -38,22 +38,15 @@
#define TOUCH_SCREEN_HOLD_TO_CALIBRATE_MS 2500
#endif
-typedef struct __attribute__((__packed__)) TouchCal : xy_long_t {
- xy_int_t offset;
+typedef struct __attribute__((__packed__)) {
+ int32_t x, y;
+ int16_t offset_x, offset_y;
uint8_t orientation;
- TouchCal() { set(xy_long_t({ 0, 0 }), xy_int_t({ 0, 0 }), TOUCH_ORIENTATION_NONE); }
- void set(const xy_long_t &xy, const xy_int_t &hv, const uint8_t o) {
- xy_long_t::set(xy); offset = hv; orientation = o;
- }
- void reset() {
- set(xy_long_t({ TOUCH_CALIBRATION_X, TOUCH_CALIBRATION_Y }),
- xy_int_t({ TOUCH_OFFSET_X, TOUCH_OFFSET_Y }),
- TOUCH_ORIENTATION);
- }
} touch_calibration_t;
-typedef struct __attribute__((__packed__)) : xy_uint_t {
- xy_int_t raw;
+typedef struct __attribute__((__packed__)) {
+ uint16_t x, y;
+ int16_t raw_x, raw_y;
} touch_calibration_point_t;
enum calibrationState : uint8_t {
@@ -72,24 +65,28 @@ public:
static touch_calibration_point_t calibration_points[4];
static millis_t next_touch_update_ms;
- static bool validate_precision(int32_t a, int32_t b) { return (a > b ? (100 * b) / a : (100 * a) / b) > (TOUCH_SCREEN_CALIBRATION_PRECISION); }
- static bool validate_precision_x(uint8_t a, uint8_t b) { return validate_precision(calibration_points[a].raw.x, calibration_points[b].raw.x); }
- static bool validate_precision_y(uint8_t a, uint8_t b) { return validate_precision(calibration_points[a].raw.y, calibration_points[b].raw.y); }
+ static bool validate_precision(int32_t a, int32_t b) { return (a > b ? (100 * b) / a : (100 * a) / b) > TOUCH_SCREEN_CALIBRATION_PRECISION; }
+ static bool validate_precision_x(uint8_t a, uint8_t b) { return validate_precision(calibration_points[a].raw_x, calibration_points[b].raw_x); }
+ static bool validate_precision_y(uint8_t a, uint8_t b) { return validate_precision(calibration_points[a].raw_y, calibration_points[b].raw_y); }
static void validate_calibration();
static touch_calibration_t calibration;
static uint8_t failed_count;
- static void calibration_reset() { calibration.set(xy_long_t({ TOUCH_CALIBRATION_X, TOUCH_CALIBRATION_Y }), xy_int_t({ TOUCH_OFFSET_X, TOUCH_OFFSET_Y }), TOUCH_ORIENTATION); }
- static bool need_calibration() { return !(calibration.offset.x || calibration.offset.y || calibration.x || calibration.y); }
+ static void calibration_reset() { calibration = { TOUCH_CALIBRATION_X, TOUCH_CALIBRATION_Y, TOUCH_OFFSET_X, TOUCH_OFFSET_Y, TOUCH_ORIENTATION }; }
+ static bool need_calibration() { return !calibration.offset_x && !calibration.offset_y && !calibration.x && !calibration.y; }
static calibrationState calibration_start() {
next_touch_update_ms = millis() + 750UL;
- calibration.reset();
+ calibration = { 0, 0, 0, 0, TOUCH_ORIENTATION_NONE };
calibration_state = CALIBRATION_TOP_LEFT;
- calibration_points[CALIBRATION_TOP_LEFT].set(30, 30);
- calibration_points[CALIBRATION_TOP_RIGHT].set(TFT_WIDTH - 31, 30);
- calibration_points[CALIBRATION_BOTTOM_RIGHT].set(TFT_WIDTH - 31, TFT_HEIGHT - 31);
- calibration_points[CALIBRATION_BOTTOM_LEFT].set(30, TFT_HEIGHT - 31);
+ calibration_points[CALIBRATION_TOP_LEFT].x = 30;
+ calibration_points[CALIBRATION_TOP_LEFT].y = 30;
+ calibration_points[CALIBRATION_TOP_RIGHT].x = TFT_WIDTH - 31;
+ calibration_points[CALIBRATION_TOP_RIGHT].y = 30;
+ calibration_points[CALIBRATION_BOTTOM_RIGHT].x = TFT_WIDTH - 31;
+ calibration_points[CALIBRATION_BOTTOM_RIGHT].y = TFT_HEIGHT - 31;
+ calibration_points[CALIBRATION_BOTTOM_LEFT].x = 30;
+ calibration_points[CALIBRATION_BOTTOM_LEFT].y = TFT_HEIGHT - 31;
failed_count = 0;
return calibration_state;
}
@@ -100,12 +97,12 @@ public:
return !need_calibration();
}
- static bool handleTouch(const xy_int_t &point);
+ static bool handleTouch(const uint16_t x, const uint16_t y);
};
extern TouchCalibration touch_calibration;
-#else // TOUCH_SCREEN_CALIBRATION
+#else // !TOUCH_SCREEN_CALIBRATION
#define _TOUCH_CALIBRATION_X (TOUCH_CALIBRATION_X)
#define _TOUCH_CALIBRATION_Y (TOUCH_CALIBRATION_Y)
diff --git a/Marlin/src/lcd/touch/touch_buttons.cpp b/Marlin/src/lcd/touch/touch_buttons.cpp
index 636a31dafa4..7d31b21c04a 100644
--- a/Marlin/src/lcd/touch/touch_buttons.cpp
+++ b/Marlin/src/lcd/touch/touch_buttons.cpp
@@ -66,6 +66,7 @@ uint8_t TouchButtons::read_buttons() {
int16_t x, y;
#if ENABLED(TFT_TOUCH_DEVICE_XPT2046)
+
const bool is_touched = TOUCH_PORTRAIT == _TOUCH_ORIENTATION
? touchIO.getRawPoint(&y, &x)
: touchIO.getRawPoint(&x, &y);
@@ -88,13 +89,16 @@ uint8_t TouchButtons::read_buttons() {
#if ENABLED(TOUCH_SCREEN_CALIBRATION)
const calibrationState state = touch_calibration.get_calibration_state();
if (WITHIN(state, CALIBRATION_TOP_LEFT, CALIBRATION_BOTTOM_LEFT)) {
- if (!no_touch && touch_calibration.handleTouch(xy_int_t({x, y}))) ui.refresh();
+ if (!no_touch && touch_calibration.handleTouch(x, y)) ui.refresh();
no_touch = true;
return 0;
}
+ x = int16_t((int32_t(x) * _TOUCH_CALIBRATION_X) >> 16) + _TOUCH_OFFSET_X;
+ y = int16_t((int32_t(y) * _TOUCH_CALIBRATION_Y) >> 16) + _TOUCH_OFFSET_Y;
+ #else
+ x = uint16_t((uint32_t(x) * _TOUCH_CALIBRATION_X) >> 16) + _TOUCH_OFFSET_X;
+ y = uint16_t((uint32_t(y) * _TOUCH_CALIBRATION_Y) >> 16) + _TOUCH_OFFSET_Y;
#endif
- x = uint16_t((uint32_t(x) * _TOUCH_CALIBRATION_X) >> 16) + _TOUCH_OFFSET_X;
- y = uint16_t((uint32_t(y) * _TOUCH_CALIBRATION_Y) >> 16) + _TOUCH_OFFSET_Y;
#elif ENABLED(TFT_TOUCH_DEVICE_GT911)