calibrate.c

Go to the documentation of this file.

#include <stdint.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>

#include "user_config.h"

#include "matrix.h"

#ifdef DISPLAY

#ifndef XPT2046
#error XPT2046 is not defined
#endif

#include "xpt2046.h"
#include "display/ili9341.h"

mat_t tft_calX;
mat_t tft_calY;

int tft_is_calibrated = 0;


MEMSPACE
int tft_check_calibrated(window *win)
{
    if(!tft_is_calibrated)
    {
        tft_touch_calibrate(win);
        return(0);
    }
    return(1);

}

MEMSPACE
int tft_touch_calibrate(window *win)
{
    int i;
    uint16_t w,h,X1,X2,Y1,Y2;
    mat_t MatAI;
    mat_t MatX = MatAlloc(5,1);
    mat_t MatY = MatAlloc(5,1);
    mat_t MatA = MatAlloc(5,3);

    w = win->w;
    h = win->h;

    if(tft_is_calibrated)
    {
        MatFree(tft_calX);
        MatFree(tft_calY);
        tft_is_calibrated = 0;
    }

    tft_fillWin(win, win->bg);
    if(win->rotation & 1)
        tft_set_font(win, 2);
    else
        tft_set_font(win, 1);
    tft_printf("Please Calibrate");


    MatX.data[0][0] = w / 4;
    MatY.data[0][0] = h / 4;

    MatX.data[1][0] = w * 3 / 4;
    MatY.data[1][0] = h / 4;

    MatX.data[2][0] = w / 4;
    MatY.data[2][0] = h * 3 / 4;

    MatX.data[3][0] = w * 3 / 4;
    MatY.data[3][0] = h * 3 / 4;

    MatX.data[4][0] = w / 2;
    MatY.data[4][0] = h / 2;

#if MATDEBUG & 2
    printf("X\n");
    MatPrint(MatX);
    printf("Y\n");
    MatPrint(MatY);
#endif

    for(i=0;i<5;++i)
    {
        X1 = MatX.data[i][0];
        Y1 = MatY.data[i][0];
        tft_fillCircle (win , X1,Y1, 5 , ILI9341_WHITE);
        tft_set_textpos(win, 0,0);
        if(win->rotation & 1)
            tft_set_font(win, 1);
        else
            tft_set_font(win, 0);

        tft_printf(win,"touch point %3d,%3d", (int)X1, (int)Y1);
        tft_cleareol(win);

        // This is the only XPT2046 specific bit of code in the file
        while( XPT2046_key((uint16_t *)&X2, (uint16_t *)&Y2) == 0 )
            optimistic_yield(1000);

        MatA.data[i][0] = (float)X2;
        MatA.data[i][1] = (float)Y2;
        MatA.data[i][2] = 1.0;
        // reset pixel
        tft_fillCircle (win , X1,Y1, 5 , win->bg);
        tft_drawPixel(win, X1, Y1, win->bg);
    }


    MatAI = PseudoInvert(MatA);

    // Calibration values
    tft_calX = MatMul(MatAI,MatX);
    tft_calY = MatMul(MatAI,MatY);

#if MATDEBUG & 2
    printf("A\n");
    MatPrint(MatA);

    printf("Invert\n");
    MatPrint(MatAI);

    printf("tft_calX\n");
    MatPrint(tft_calX);

    printf("tft_calY\n");
    MatPrint(tft_calY);
#endif

    MatFree(MatA);
    MatFree(MatX);
    MatFree(MatY);
    MatFree(MatAI);

    return( (tft_is_calibrated = 1) );
}

MEMSPACE
int tft_touch_map(window *win, int16_t *X, int16_t *Y)
{
    int16_t X2,Y2;
    float XF,YF;

    if(!tft_check_calibrated(win))
    {
        return(0);
    }

    XF = (float)*X;
    YF = (float)*Y;
#if MATDEBUG & 2
    printf("tft_touch_map: raw: X:%.0f,Y:%.0f\n", (double)XF, (double)YF);
#endif
    X2 = (uint16_t)(tft_calX.data[0][0] * XF + tft_calX.data[1][0] * YF + tft_calX.data[2][0]);
    Y2 = (uint16_t)(tft_calY.data[0][0] * XF + tft_calY.data[1][0] * YF + tft_calY.data[2][0]);
#if MATDEBUG & 2
    printf("tft_touch_map: cal: X:%3d,Y:%3d\n", (int)X2, (int)Y2);
#endif

    // force result to fix in window limits
    tft_clip_xy(win,X,Y);
        
    *X = X2;
    *Y = Y2;
    return(1);
}


MEMSPACE
int tft_map_test(window *win, int points)
{
    int i;
    int16_t X1,Y1;

    tft_fillWin(win, win->bg);
    if(win->rotation & 1)
        tft_set_font(win, 1);
    else
        tft_set_font(win, 0);
    tft_printf(win,"press %d points", points);

    if(!tft_check_calibrated(win))
    {
        return(0);
    }

    for(i=0;i<points;++i)
    {
        while( XPT2046_key((uint16_t *)&X1, (uint16_t *)&Y1) == 0 )
            optimistic_yield(1000);

        tft_touch_map(win,&X1,&Y1);
        tft_fillCircle (win , X1,Y1, 5 , ILI9341_WHITE);
    }
    return(1);
}

MEMSPACE
int tft_touch_xy_raw(window *win, uint16_t *X, uint16_t *Y)
{
    int T;
    T = XPT2046_xy_raw(X, Y);
    tft_touch_map(win,X,Y);
    return(T);
}

MEMSPACE
int tft_touch_xy(window *win, uint16_t *X, uint16_t *Y)
{
    int T;
    T = XPT2046_xy_filtered(X, Y);
    tft_touch_map(win,X,Y);
    return(T);
}
    

MEMSPACE
int tft_touch_key(window *win, uint16_t *X, uint16_t *Y)
{

    int T;
    T = XPT2046_key(X,Y);
    tft_touch_map(win,X,Y);
    return(T);
}
#endif  //DISPLAY