Tasmota/tasmota/berry/modules/ts_calibrate/ts_calibrate.be

326 lines
11 KiB
Plaintext

# TouchScreen calibration
#
# rm DisplayCalibrate.tapp; zip -j -0 DisplayCalibrate.tapp ts_calibrate/*
#
var ts_calibrate = module("ts_calibrate")
ts_calibrate.init = def (m)
class TS_Calibrate
var l1, l2 # LVGL lines used to draw a cross
var p1, p2, p3, p4 # points needs to be kept in memory across calls
var pt_arr1, pt_arr2
var f20 # font Montserrat 20
var scr_orig # original screen
var scr_ts # screen used for calibration
var hres, vres
var instr_label # label for instructions
#
var raw_pts # 4x raw points for 4 corners
var raw_pts_weight # weight for current corner, used for an aveage measure
#
var state_closure # closure to call at next iteration
var state_corner # which corner are we now tracking
#
var m_line # display.ini parsed, array of 2 string (before and after :M line)
static msg_prefix = "Touch Screen calibration\n"
static msg_touch = "Press the center of\n"
static msg_corners = [ "upper left cross", "upper right cross", "lower left cross", "lower right cross" ]
static msg_ok = "Calibration successful\nRestarting in 5 seconds"
static msg_nok = "Calibration failed\nPlease try again"
static round = def (v) return int(v + 0.5) end
def init()
end
def start()
self.state_corner= -1 # no corner being tracked yet
self.m_line = nil
# check display.ini to see if touchscreen is present with ':M' line in display.ini
self.m_line = self.load_m_line()
if !self.m_line
tasmota.log("TS : Abort, no touchscreen ':M' line present in 'display.ini'", 2)
return
end
lv.start()
# check if `DisplayRotate` is set to zero
var display_rotate_ret = tasmota.cmd("DisplayRotate")
if display_rotate_ret != nil && display_rotate_ret["DisplayRotate"] != 0
tasmota.log("TS : Calibration requires 'DisplayRotate 0'")
return
end
self.raw_pts = [ lv.point(), lv.point(), lv.point(), lv.point() ]
self.scr_orig = lv.scr_act() # save the current screen to restore it later
self.f20 = lv.montserrat_font(20) # load embedded Montserrat 20
self.hres = lv.get_hor_res()
self.vres = lv.get_ver_res()
self.scr_ts = lv.obj(0) # create a new temporary screen for the calibration
lv.scr_load(self.scr_ts)
self.instr_label = lv.label(self.scr_ts)
self.instr_label.center()
if self.f20 != nil self.instr_label.set_style_text_font(self.f20, lv.PART_MAIN | lv.STATE_DEFAULT) end
self.instr_label.set_text(self.msg_prefix)
self.l1 = lv.line(self.scr_ts)
self.l2 = lv.line(self.scr_ts)
self.l1.set_style_line_width(2, lv.PART_MAIN | lv.STATE_DEFAULT)
self.l2.set_style_line_width(2, lv.PART_MAIN | lv.STATE_DEFAULT)
self.p1 = lv.point()
self.p2 = lv.point()
self.p3 = lv.point()
self.p4 = lv.point()
# register ourselves as driver
tasmota.add_driver(self)
# start calibrate in 2 seconds
tasmota.set_timer(2000, /-> self.do_next_corner())
end
def do_cross_n(n)
self.state_corner = n
self.raw_pts_weight = 0 # reset weight (for average of measures)
if n == 0 self.draw_cross(20,20,30)
elif n == 1 self.draw_cross(self.hres - 20, 20, 30)
elif n == 2 self.draw_cross(20, self.vres - 20, 30)
else self.draw_cross(self.hres - 20, self.vres - 20, 30)
end
# set message
self.instr_label.set_text(self.msg_prefix + self.msg_touch + self.msg_corners[n])
end
# remove and restore previous state
def del()
lv.scr_load(self.scr_orig) # restore previous screen
self.scr_ts.del() # delete all objects
tasmota.remove_driver(self)
end
# draw cross
def draw_cross(x, y, sz)
var sz2 = sz / 2
self.p1.x = x - sz2
self.p1.y = y
self.p2.x = x + sz2
self.p2.y = y
self.pt_arr1 = lv.lv_point_arr([self.p1, self.p2])
self.l1.set_points(self.pt_arr1, 2)
self.p3.x = x
self.p3.y = y - sz2
self.p4.x = x
self.p4.y = y + sz2
self.pt_arr2 = lv.lv_point_arr([self.p3, self.p4])
self.l2.set_points(self.pt_arr2, 2)
end
def every_50ms()
#
if self.state_closure self.state_closure() end
end
def track_touch_screen()
var tracking = lv.get_ts_calibration()
if tracking.state
# screen is pressed, compute an average of all previous measures
self.raw_pts[self.state_corner].x = (self.raw_pts[self.state_corner].x * self.raw_pts_weight + tracking.raw_x) / (self.raw_pts_weight + 1)
self.raw_pts[self.state_corner].y = (self.raw_pts[self.state_corner].y * self.raw_pts_weight + tracking.raw_y) / (self.raw_pts_weight + 1)
self.raw_pts_weight += 1 # we now have 1 more measure
else
# screen is not pressed anymore
if (self.raw_pts_weight >= 3)
self.state_closure = nil # stop tracking
tasmota.set_timer(0, /-> self.do_next_corner()) # defer to next corner
end # we need at least 3 succesful measures do consider complete
end
end
def do_next_corner()
# start the measure of the next corner
self.state_corner += 1
if self.state_corner <= 3
self.do_cross_n(self.state_corner)
self.state_closure = /-> self.track_touch_screen()
else
# finished
self.l1.del()
self.l2.del()
self.finish()
end
end
# All values are computed and correct, log results and store to 'display.ini'
def finish()
# calibration is finished, do the housekeeping
import string
var p0x = real(self.raw_pts[0].x)
var p0y = real(self.raw_pts[0].y)
var p1x = real(self.raw_pts[1].x)
var p1y = real(self.raw_pts[1].y)
var p2x = real(self.raw_pts[2].x)
var p2y = real(self.raw_pts[2].y)
var p3x = real(self.raw_pts[3].x)
var p3y = real(self.raw_pts[3].y)
tasmota.log(string.format("TS : Calibration (%i,%i) - (%i,%i) - (%i,%i) - (%i,%i)",
int(p0x), int(p0y), int(p1x), int(p1y), int(p2x), int(p2y), int(p3x), int(p3y))
, 2)
var m_line = self.calc_geometry(p0x, p0y, p1x, p1y, p2x, p2y, p3x, p3y, self.hres, self.vres, 20)
var ok = false
if m_line
ok = self.update_display_ini(m_line)
end
if ok
self.instr_label.set_text(self.msg_prefix + self.msg_ok)
else
self.instr_label.set_text(self.msg_prefix + self.msg_nok)
end
tasmota.set_timer(3000, /->self.cleanup(ok))
end
# cleanup display, remove any widgets created
def cleanup(restart)
self.del()
if (restart)
tasmota.cmd("Restart 1")
end
end
# Find 'display.ini' file either in root folder or in autoconf file
# and check that it contains a line ':M*'
# Returns an array of 2 strings (before and after :M line)
# or 'nil' if not found
def load_m_line()
try
import re
import path
# try display.ini at root
var disp_ini
if path.exists("display.ini")
var disp_f = open("display.ini")
disp_ini = disp_f.read()
disp_f.close()
elif autoconf.get_current_module_path() && path.exists(autoconf.get_current_module_path() + "#display.ini")
var disp_f = open(autoconf.get_current_module_path() + "#display.ini")
disp_ini = disp_f.read()
disp_f.close()
else
return nil
end
# look for ":M" line
var sp = re.split(":M.*?\n", disp_ini)
if size(sp) == 2
return sp # found
end
except .. as e, m
tasmota.log("TS : Couldn't open 'display.ini': "+str(e)+" '"+str(m)+"'")
end
return nil
end
# try to update 'display.ini' if present in file-system
def update_display_ini(m_line)
try
# found
var disp_ini = self.m_line[0] + str(m_line) + "\n" + self.m_line[1]
# write back file
var disp_f = open("display.ini", "w")
disp_f.write(disp_ini)
disp_f.close()
tasmota.log("TS : Successfully updated 'display.ini'", 2)
return true
except .. as e, m
tasmota.log("TS : Error updating 'display.ini': "+str(e)+" '"+str(m)+"'")
end
return false
end
def calc_geometry(p0x, p0y, p1x, p1y, p2x, p2y, p3x, p3y, hres, vres, padding)
import math
import string
tasmota.log(string.format("TS : Geometry (%i,%i) (%i,%i) (%i,%i) (%i,%i) - %ix%i pad %i",
int(p0x), int(p0y),
int(p1x), int(p1y),
int(p2x), int(p2y),
int(p3x), int(p3y),
int(hres), int(vres), int(padding)
), 3)
var vec_01_x = p1x - p0x
var vec_01_y = p1y - p0y
var norm_01 = math.sqrt(vec_01_x * vec_01_x + vec_01_y * vec_01_y)
var vec_02_x = p2x - p0x
var vec_02_y = p2y - p0y
var norm_02 = math.sqrt(vec_01_x * vec_01_x + vec_01_y * vec_01_y)
var scalar_01_02 = vec_01_x * vec_02_x + vec_01_y * vec_02_y
var cos_th_01_02 = math.abs(scalar_01_02) / norm_01 / norm_02
tasmota.log("cos_th_01_02=" + str(cos_th_01_02), 4)
if (cos_th_01_02 > 0.05)
tasmota.log("TS : Wrong geometry - bad angle. Try again.", 2)
return nil
end
# Now check the center is valid
var center_03_x = (p0x + p3x) / 2
var center_03_y = (p0y + p3y) / 2
var center_12_x = (p1x + p2x) / 2
var center_12_y = (p1y + p2y) / 2
var norm_delta_centers = ((center_12_x - center_03_x) * (center_12_x - center_03_x) + (center_12_y - center_03_y) * (center_12_y - center_03_y)) / norm_01 / norm_02
tasmota.log("norm_delta_centers=" + str(norm_delta_centers), 4)
if (norm_delta_centers > 0.02)
tasmota.log("TS : Wrong geometry - bad center. Try again", 2)
return nil
end
var xmin = (p0x + p2x) / 2
var xmax = (p1x + p3x) / 2
var ymin = (p0y + p1y) / 2
var ymax = (p2y + p3y) / 2
tasmota.log("raw xmin=" + str(xmin) + " xmax=" + str(xmax) + " ymin=" + str(ymin) + " ymax=" + str(ymax), 4)
var range_x = xmax - xmin
var range_y = ymax - ymin
tasmota.log("range_x=" + str(range_x) + " range_y=" + str(range_y), 4)
var extend_x = (range_x / (hres - 2*padding) * hres - range_x) / 2
var extend_y = (range_y / (vres - 2*padding) * vres - range_y) / 2
xmin -= extend_x
xmax += extend_x
ymin -= extend_y
ymax += extend_y
tasmota.log("final xmin=" + str(xmin) + " xmax=" + str(xmax) + " ymin=" + str(ymin) + " ymax=" + str(ymax), 4)
var M_string = string.format(":M,%i,%i,%i,%i", int(xmin), int(xmax), int(ymin), int(ymax))
tasmota.log(string.format("TS : Add this to display.ini '%s'", M_string))
return M_string
end
end
return TS_Calibrate()
end
return ts_calibrate