Changes to the touch calibration

[kdschlosser]

There have been problems plaguing the touch calibration for some time. I spent some time today and i "dumbed" down the code a lot. It is super simple with a colored 20 x 20 dot that will appear that will need to be pressed a total of 8 times. pressing and holding will also work. the coordinates when they are collected will get printed out to the REPL.

I have had some people ask about using the values given from TFT_eSPI's calibration. This cannot be done. the TFT_eSPI Arduino library does not handle a touch screen being adhered to a display crooked/rotated slightly. It doesn't run calculations that build a transform matrix. It simply remaps x and y touch coordinates to display coordinates. I know this because it only uses 2 points x0, y0, x1, y1 for the coordinates and there is an additional integer that is a simple bit shift that holds x mirror, y mirror and swap xy.

These are the calculations that I am using:

    # removed the min and max values for x, y from the collected points.
    # this helps to reduce any outliers 
    # then I get the average of the remaining points.
    for i, points in enumerate(captured_points):
        points['x'].remove(max(points['x']))
        points['x'].remove(min(points['x']))
        points['y'].remove(max(points['y']))
        points['y'].remove(min(points['y']))

        points['x'] = int(sum(points['x']) / 6)
        points['y'] = int(sum(points['y']) / 6)


    tp1, tp2, tp3 = captured_points
    sp1, sp2, sp3 = target_points

    divisor = float(
            tp1['x'] * (tp3['y'] - tp2['y']) - tp2['x'] * tp3['y'] +
            tp2['y'] * tp3['x'] + tp1['y'] * (tp2['x'] - tp3['x'])
    )
    alphaX = float(
            sp1['x'] * (tp3['y'] - tp2['y']) - sp2['x'] * tp3['y'] +
            sp3['x'] * tp2['y'] + (sp2['x'] - sp3['x']) * tp1['y']
    ) / divisor
    print('  alphaX:', alphaX)
    betaX = -float(
            sp1['x'] * (tp3['x'] - tp2['x']) - sp2['x'] * tp3['x'] +
            sp3['x'] * tp2['x'] + (sp2['x'] - sp3['x']) * tp1['x']
    ) / divisor
    print('  betaX:', betaX)
    deltaX = float(
            sp1['x'] * (tp2['y'] * tp3['x'] - tp2['x'] * tp3['y']) +
            tp1['x'] * (sp2['x'] * tp3['y'] - sp3['x'] * tp2['y']) +
            tp1['y'] * (sp3['x'] * tp2['x'] - sp2['x'] * tp3['x'])
    ) / divisor
    print('  deltaX:', deltaX)
    alphaY = float(
            sp1['y'] * (tp3['y'] - tp2['y']) - sp2['y'] * tp3['y'] +
            sp3['y'] * tp2['y'] + (sp2['y'] - sp3['y']) * tp1['y']
    ) / divisor
    print('  alphaY:', alphaY)
    betaY = -float(
            sp1['y'] * (tp3['x'] - tp2['x']) - sp2['y'] * tp3['x'] +
            sp3['y'] * tp2['x'] + (sp2['y'] - sp3['y']) * tp1['x']
    ) / divisor
    print('  betaY:', betaY)
    deltaY = float(
            sp1['y'] * (tp2['y'] * tp3['x'] - tp2['x'] * tp3['y']) +
            tp1['x'] * (sp2['y'] * tp3['y'] - sp3['y'] * tp2['y']) +
            tp1['y'] * (sp3['y'] * tp2['x'] - sp2['y'] * tp3['x'])
    ) / divisor
    print('  deltaY:', deltaY)

And the code that is used to create the matrix and correct the x, y coordinates:

x = int(round(x * cal.alphaX + y * cal.betaX + cal.deltaX))
y = int(round(x * cal.alphaY + y * cal.betaY + cal.deltaY))

This is a way more complex calibration than the one used in TFT_eSPI which enables it to handle things like the touch panel not being attached to the display 100% straight. It can be slightly crooked and it will properly adjust the input coordinates to the correct display coordinates.