path: root/bsp/nuvoton/libraries/nu_packages/ADC_TOUCH/adc_touch.c

/**************************************************************************//**
* @copyright (C) 2020 Nuvoton Technology Corp. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date            Author       Notes
* 2021-04-20      Wayne        First version
*
******************************************************************************/

#include <rtconfig.h>

#if defined(NU_PKG_USING_ADC_TOUCH)

#include "NuMicro.h"
#include <rtdevice.h>
#include <dfs_file.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/stat.h>
#include <sys/statfs.h>
//#include "drv_adc.h"
#include "adc_touch.h"

#if !defined(PATH_CALIBRATION_FILE)
    #define PATH_CALIBRATION_FILE "/mnt/filesystem/ts_calibration"
#endif

rt_err_t nu_adc_touch_disable(void);
rt_err_t nu_adc_touch_enable(rt_touch_t psRtTouch);
void nu_adc_touch_detect(rt_bool_t bStartDetect);
int32_t nu_adc_touch_read_xyz(uint32_t *bufX, uint32_t *bufY, uint32_t *bufZ0, uint32_t *bufZ1, int32_t dataCnt);

typedef struct
{
    struct rt_touch_device dev;
    rt_uint32_t x_range;
    rt_uint32_t y_range;
} nu_adc_touch;
typedef nu_adc_touch *nu_adc_touch_t;

static nu_adc_touch s_NuAdcTouch = {0};

/* User can define ADC touch calibration matrix in board_dev.c. */
rt_weak S_CALIBRATION_MATRIX g_sCalMat = { 1, 0, 0, 0, 1, 0, 1 };
static volatile uint32_t g_u32Calibrated = 0;

static int nu_adc_touch_readfile(void);

static const S_CALIBRATION_MATRIX g_sCalZero = { 1, 0, 0, 0, 1, 0, 1 };

static int nu_adc_cal_mat_get(const S_COORDINATE_POINT *psDispCP, S_COORDINATE_POINT *psADCCP, S_CALIBRATION_MATRIX *psCM)
{
#if (DEF_CAL_POINT_NUM==3)

    psCM->div = ((psADCCP[0].x - psADCCP[2].x) * (psADCCP[1].y - psADCCP[2].y)) -
                ((psADCCP[1].x - psADCCP[2].x) * (psADCCP[0].y - psADCCP[2].y)) ;

    if (psCM->div == 0)
    {
        return -1;
    }
    else
    {
        psCM->a = ((psDispCP[0].x - psDispCP[2].x) * (psADCCP[1].y - psADCCP[2].y)) -
                  ((psDispCP[1].x - psDispCP[2].x) * (psADCCP[0].y - psADCCP[2].y)) ;

        psCM->b = ((psADCCP[0].x - psADCCP[2].x) * (psDispCP[1].x - psDispCP[2].x)) -
                  ((psDispCP[0].x - psDispCP[2].x) * (psADCCP[1].x - psADCCP[2].x)) ;

        psCM->c = (psADCCP[2].x * psDispCP[1].x - psADCCP[1].x * psDispCP[2].x) * psADCCP[0].y +
                  (psADCCP[0].x * psDispCP[2].x - psADCCP[2].x * psDispCP[0].x) * psADCCP[1].y +
                  (psADCCP[1].x * psDispCP[0].x - psADCCP[0].x * psDispCP[1].x) * psADCCP[2].y ;

        psCM->d = ((psDispCP[0].y - psDispCP[2].y) * (psADCCP[1].y - psADCCP[2].y)) -
                  ((psDispCP[1].y - psDispCP[2].y) * (psADCCP[0].y - psADCCP[2].y)) ;

        psCM->e = ((psADCCP[0].x - psADCCP[2].x) * (psDispCP[1].y - psDispCP[2].y)) -
                  ((psDispCP[0].y - psDispCP[2].y) * (psADCCP[1].x - psADCCP[2].x)) ;

        psCM->f = (psADCCP[2].x * psDispCP[1].y - psADCCP[1].x * psDispCP[2].y) * psADCCP[0].y +
                  (psADCCP[0].x * psDispCP[2].y - psADCCP[2].x * psDispCP[0].y) * psADCCP[1].y +
                  (psADCCP[1].x * psDispCP[0].y - psADCCP[0].x * psDispCP[1].y) * psADCCP[2].y ;
    }

#elif (DEF_CAL_POINT_NUM==5)

    int i;
    float n, x, y, xx, yy, xy, z, zx, zy;
    float a, b, c, d, e, f, g;
    float scaling = 65536.0f;

    n = x = y = xx = yy = xy = 0;
    for (i = 0; i < DEF_CAL_POINT_NUM; i++)
    {
        n  += (float)1.0;
        x  += (float)psADCCP[i].x;
        y  += (float)psADCCP[i].y;
        xx += (float)psADCCP[i].x * psADCCP[i].x;
        yy += (float)psADCCP[i].y * psADCCP[i].y;
        xy += (float)psADCCP[i].x * psADCCP[i].y;
    }

    d = n * (xx * yy - xy * xy) + x * (xy * y - x * yy) + y * (x * xy - y * xx);
    if (d < (float)0.1 && d > (float) -0.1)
    {
        return -1;
    }

    a = (xx * yy - xy * xy) / d;
    b = (xy * y  - x * yy)  / d;
    c = (x * xy  - y * xx)  / d;
    e = (n * yy  - y * y)   / d;
    f = (x * y   - n * xy)  / d;
    g = (n * xx  - x * x)   / d;

    z = zx = zy = 0;
    for (i = 0; i < DEF_CAL_POINT_NUM; i++)
    {
        z  += (float)psDispCP[i].x;
        zx += (float)psDispCP[i].x * psADCCP[i].x;
        zy += (float)psDispCP[i].x * psADCCP[i].y;
    }

    psCM->c = (int32_t)((a * z + b * zx + c * zy) * scaling);
    psCM->a = (int32_t)((b * z + e * zx + f * zy) * scaling);
    psCM->b = (int32_t)((c * z + f * zx + g * zy) * scaling);

    z = zx = zy = 0;
    for (i = 0; i < DEF_CAL_POINT_NUM; i++)
    {
        z  += (float)psDispCP[i].y;
        zx += (float)psDispCP[i].y * psADCCP[i].x;
        zy += (float)psDispCP[i].y * psADCCP[i].y;
    }

    psCM->f = (int32_t)((a * z + b * zx + c * zy) * scaling);
    psCM->d = (int32_t)((b * z + e * zx + f * zy) * scaling);
    psCM->e = (int32_t)((c * z + f * zx + g * zy) * scaling);

    psCM->div = (int32_t)scaling;

#else
#error "Not supported calibration method"
#endif
    return 0;
}

static void nu_adc_touch_cal(int32_t *sumx, int32_t *sumy)
{
    int32_t xtemp, ytemp;

    xtemp = *sumx;
    ytemp = *sumy;
    *sumx = (g_sCalMat.c +
             g_sCalMat.a * xtemp +
             g_sCalMat.b * ytemp) / g_sCalMat.div;
    *sumy = (g_sCalMat.f +
             g_sCalMat.d * xtemp +
             g_sCalMat.e * ytemp) / g_sCalMat.div;
}

static rt_size_t nu_adc_touch_readpoint(struct rt_touch_device *device, void *buf, rt_size_t read_num)
{
    static uint32_t last_report_x = 0, last_report_y = 0;
    struct rt_touch_data *pPoint = (struct rt_touch_data *)buf;
    nu_adc_touch_t psNuAdcTouch = (nu_adc_touch_t)device;

    RT_ASSERT(device != RT_NULL);
    RT_ASSERT(buf != RT_NULL);

    int i;

    for (i = 0; i < read_num; i++)
    {
        uint32_t bufZ0 = 0, bufZ1 = 0;
        int32_t sumx = 0, sumy = 0;
        pPoint[i].timestamp = rt_touch_get_ts();
        pPoint[i].track_id = 0;

        if (nu_adc_touch_read_xyz((uint32_t *)&sumx, (uint32_t *)&sumy, &bufZ0, &bufZ1, 1) != 1)
            break;

        if (bufZ0 == 0)
        {
            /* Workaround: In this case, x, y values are unstable. so, report last point's coordinate.*/
            pPoint[i].event = RT_TOUCH_EVENT_UP;
            pPoint[i].x_coordinate = (uint16_t)last_report_x;
            pPoint[i].y_coordinate = (uint16_t)last_report_y;
        }
        else
        {
            if (g_u32Calibrated)
            {
                nu_adc_touch_cal(&sumx, &sumy);
            }
            last_report_x = sumx;
            last_report_y = sumy;

            pPoint[i].event = RT_TOUCH_EVENT_DOWN;
            pPoint[i].x_coordinate = (uint16_t)sumx;
            pPoint[i].y_coordinate = (uint16_t)sumy;
        }

        if (g_u32Calibrated)
        {
            bufZ0 = bufZ0 >> 3;
            pPoint[i].width = (bufZ0 > 255) ? 255 : bufZ0;

            //Limit max x, y coordinate if value is over its range.
            pPoint[i].x_coordinate = (pPoint[i].x_coordinate > psNuAdcTouch->x_range) ? psNuAdcTouch->x_range : pPoint[i].x_coordinate;
            pPoint[i].y_coordinate = (pPoint[i].y_coordinate > psNuAdcTouch->y_range) ? psNuAdcTouch->y_range : pPoint[i].y_coordinate;
        }
    }
    return (rt_size_t)i;
}

static rt_err_t nu_adc_touch_control(struct rt_touch_device *device, int cmd, void *data)
{
    nu_adc_touch_t psNuAdcTouch = (nu_adc_touch_t)device;
    RT_ASSERT(psNuAdcTouch != RT_NULL);

    switch (cmd)
    {
    case RT_TOUCH_CTRL_SET_X_RANGE: /* set x range */
        psNuAdcTouch->x_range = *((rt_int32_t *)data);
        break;

    case RT_TOUCH_CTRL_SET_Y_RANGE: /* set y range */
        psNuAdcTouch->y_range = *((rt_int32_t *)data);
        break;

    case RT_TOUCH_CTRL_ENABLE_INT: /* enable pen_down interrupt */
        nu_adc_touch_detect(RT_TRUE);
        break;

    case RT_TOUCH_CTRL_DISABLE_INT: /* disable pen_down interrupt */
        nu_adc_touch_detect(RT_FALSE);
        break;

    case RT_TOUCH_CTRL_POWER_ON:    /* Touch Power On */
        return nu_adc_touch_enable(device);

    case RT_TOUCH_CTRL_POWER_OFF:   /* Touch Power Off */
        return nu_adc_touch_disable();

    default:
        return -RT_ERROR;
    }
    return RT_EOK;
}

static struct rt_touch_ops touch_ops =
{
    .touch_readpoint = nu_adc_touch_readpoint,
    .touch_control = nu_adc_touch_control,
};

static void nu_adc_touch_update_calmat(S_CALIBRATION_MATRIX *psNewCalMat)
{
    if (psNewCalMat &&
            psNewCalMat->div != 0)
    {
        rt_memcpy(&g_sCalMat, psNewCalMat, sizeof(S_CALIBRATION_MATRIX));
        g_u32Calibrated = 1;
        rt_kprintf("Applied calibration data: %d, %d, %d, %d, %d, %d, %d\n",
                   g_sCalMat.a,
                   g_sCalMat.b,
                   g_sCalMat.c,
                   g_sCalMat.d,
                   g_sCalMat.e,
                   g_sCalMat.f,
                   g_sCalMat.div);

    }
}

static void nu_adc_touch_reset_calmat(void)
{
    rt_memcpy(&g_sCalMat, &g_sCalZero, sizeof(S_CALIBRATION_MATRIX));
    g_u32Calibrated = 0;
}

int rt_hw_adc_touch_init(void)
{
    /* Register touch device */
    s_NuAdcTouch.dev.info.type = RT_TOUCH_TYPE_RESISTANCE;
    s_NuAdcTouch.dev.info.vendor = RT_TOUCH_VENDOR_UNKNOWN;
    s_NuAdcTouch.dev.info.point_num = 1;
    s_NuAdcTouch.dev.info.range_x = BSP_LCD_WIDTH;
    s_NuAdcTouch.dev.info.range_y = BSP_LCD_HEIGHT;

    s_NuAdcTouch.dev.ops = &touch_ops;

    return (int)rt_hw_touch_register(&s_NuAdcTouch.dev, "adc_touch", RT_DEVICE_FLAG_INT_RX, RT_NULL);
}
INIT_DEVICE_EXPORT(rt_hw_adc_touch_init);


static rt_thread_t  adc_touch_thread = RT_NULL;
static rt_sem_t     adc_touch_sem = RT_NULL;
static int          adc_touch_worker_run = 0;

static rt_err_t adc_touch_rx_callback(rt_device_t dev, rt_size_t size)
{
    //rt_kprintf("[%s %d] %d\n", __func__, __LINE__, size);
    return rt_sem_release(adc_touch_sem);
}

static rt_err_t adc_request_point(rt_device_t pdev, struct rt_touch_data *psTouchPoint)
{
    rt_err_t ret = -RT_ERROR;

    if ((ret = rt_sem_take(adc_touch_sem, rt_tick_from_millisecond(500))) == RT_EOK)
    {
        rt_memset(psTouchPoint, 0, sizeof(struct rt_touch_data));

        if (rt_device_read(pdev, 0, psTouchPoint, s_NuAdcTouch.dev.info.point_num) == s_NuAdcTouch.dev.info.point_num)
        {
            ret = RT_EOK;
        }

    }

    return ret;
}

rt_weak void nu_touch_inputevent_cb(rt_int16_t x, rt_int16_t y, rt_uint8_t event)
{
}

static rt_device_t lcd_device = 0;
static struct rt_device_graphic_info info;

static void lcd_cleanscreen(void)
{
    if (info.framebuffer != RT_NULL)
    {
        if (rt_device_control(lcd_device, RTGRAPHIC_CTRL_PAN_DISPLAY, (void *)info.framebuffer) == RT_EOK)
        {
            /* Sync-type LCD panel, will fill to VRAM directly. */
            rt_memset(info.framebuffer, 0, (info.pitch * info.height));
        }
        else
        {
            /* MPU-type LCD panel, fill to shadow RAM, then flush. */
            struct rt_device_rect_info rectinfo;
            int filled_line_num = 0;
            int i32LineBufNum = info.smem_len / info.pitch;
            int i32RemainLineNum = info.height;

            i32LineBufNum = (i32LineBufNum > info.height) ? info.height : i32LineBufNum;

            while (i32RemainLineNum > 0)
            {
                int pixel_count;
                rectinfo.x = 0;
                rectinfo.y = filled_line_num;
                rectinfo.width = info.width;
                rectinfo.height = (i32RemainLineNum > i32LineBufNum) ? i32LineBufNum : i32RemainLineNum ;

                pixel_count = info.width * rectinfo.height;
                rt_uint16_t *pu16ShadowBuf = (rt_uint16_t *)info.framebuffer;

                while (pixel_count > 0)
                {
                    *pu16ShadowBuf++ = 0;
                    pixel_count--;
                }
                rt_device_control(lcd_device, RTGRAPHIC_CTRL_RECT_UPDATE, &rectinfo);
                filled_line_num += i32LineBufNum;
                i32RemainLineNum -= rectinfo.height;
            }
        }
    }
    else
    {
        // TODO
    }
}

#define DEF_DOT_NUMBER    9
#define DOTS_NUMBER       (DEF_DOT_NUMBER*DEF_DOT_NUMBER)
static void nu_draw_bots(int x, int y)
{
    if (info.framebuffer != RT_NULL)
    {
        /* Rendering */
        struct rt_device_rect_info rect;
        int i, j;
        int start_x = x - (DEF_DOT_NUMBER / 2);
        int start_y = y - (DEF_DOT_NUMBER / 2);
        rt_bool_t bDrawDirect;

        if (rt_device_control(lcd_device, RTGRAPHIC_CTRL_PAN_DISPLAY, (void *)info.framebuffer) == RT_EOK)
        {
            /* Sync-type LCD panel, will draw to VRAM directly. */
            bDrawDirect = RT_TRUE;
        }
        else
        {
            /* MPU-type LCD panel, draw to shadow RAM, then flush. */
            bDrawDirect = RT_FALSE;
        }

        if (info.pixel_format == RTGRAPHIC_PIXEL_FORMAT_RGB565)
        {
            uint16_t *pu16Start = (bDrawDirect == RT_TRUE) ? (uint16_t *)((uint32_t)info.framebuffer + (start_y) * info.pitch + (start_x * 2)) : (uint16_t *)info.framebuffer;
            for (i = 0; i < DEF_DOT_NUMBER; i++)
            {
                for (j = 0; j < DEF_DOT_NUMBER; j++)
                {
                    *pu16Start = 0x07E0; //Green, RGB565
                    pu16Start++;
                }
                if (bDrawDirect)
                    pu16Start += (info.width - DEF_DOT_NUMBER);
            }
        }
        else if (info.pixel_format == RTGRAPHIC_PIXEL_FORMAT_ARGB888)
        {
            uint32_t *pu32Start = (bDrawDirect == RT_TRUE) ? (uint32_t *)((uint32_t)info.framebuffer + (start_y) * info.pitch + (start_x * 4)) : (uint32_t *)info.framebuffer;
            for (i = 0; i < DEF_DOT_NUMBER; i++)
            {
                for (j = 0; j < DEF_DOT_NUMBER; j++)
                {
                    *pu32Start = 0xff00ff00; //Green, ARGB888
                    pu32Start++;
                }
                if (bDrawDirect)
                    pu32Start += (info.width - DEF_DOT_NUMBER);
            }
        }
        else
        {
            //Not supported
            return;
        }

        if (!bDrawDirect)
        {
            /* Region updating */
            rect.x      = start_x;
            rect.y      = start_y;
            rect.width  = DEF_DOT_NUMBER;
            rect.height = DEF_DOT_NUMBER;
            rt_device_control(lcd_device, RTGRAPHIC_CTRL_RECT_UPDATE, &rect);
        }
    }
    else
    {
        // TODO
    }

    return;

}

#if (DEF_CAL_POINT_NUM==3)
const S_COORDINATE_POINT sDispPoints[DEF_CAL_POINT_NUM] =
{
    {BSP_LCD_WIDTH / 4, BSP_LCD_HEIGHT / 2},
    {BSP_LCD_WIDTH - BSP_LCD_WIDTH / 4, BSP_LCD_HEIGHT / 4},
    {BSP_LCD_WIDTH / 2, BSP_LCD_HEIGHT - BSP_LCD_HEIGHT / 4}
};
#elif (DEF_CAL_POINT_NUM==5)
const static S_COORDINATE_POINT sDispPoints[DEF_CAL_POINT_NUM] =
{
#define DEF_CUT_PIECES 8
    {BSP_LCD_WIDTH / DEF_CUT_PIECES, BSP_LCD_HEIGHT / DEF_CUT_PIECES},
    {BSP_LCD_WIDTH - BSP_LCD_WIDTH / DEF_CUT_PIECES, BSP_LCD_HEIGHT / DEF_CUT_PIECES},
    {BSP_LCD_WIDTH - BSP_LCD_WIDTH / DEF_CUT_PIECES, BSP_LCD_HEIGHT - BSP_LCD_HEIGHT / DEF_CUT_PIECES},
    {BSP_LCD_WIDTH / DEF_CUT_PIECES, BSP_LCD_HEIGHT - BSP_LCD_HEIGHT / DEF_CUT_PIECES},

    {BSP_LCD_WIDTH / 2, BSP_LCD_HEIGHT / 2}
};
#endif

static int nu_adc_touch_readfile(void)
{
    int fd;

    S_CALIBRATION_MATRIX sCalMat;

    if ((fd = open(PATH_CALIBRATION_FILE, O_RDONLY, 0)) < 0)
    {
        goto exit_nu_adc_touch_readfile;
    }
    else if (read(fd, &sCalMat, sizeof(S_CALIBRATION_MATRIX)) == sizeof(S_CALIBRATION_MATRIX))
    {
        rt_kprintf("[%s] %s\n", __func__, PATH_CALIBRATION_FILE);
    }

    close(fd);

    nu_adc_touch_update_calmat(&sCalMat);

    return 0;

exit_nu_adc_touch_readfile:

    return -1;
}

static int nu_adc_touch_writefile(void *buf, int buf_len)
{
    int fd;

    if ((fd = open(PATH_CALIBRATION_FILE, O_WRONLY | O_CREAT, 0)) < 0)
    {
        goto exit_nu_adc_touch_writefile;
    }
    else if (write(fd, buf, buf_len) == buf_len)
    {
        rt_kprintf("[%s] %s\n", __func__, PATH_CALIBRATION_FILE);
    }

    close(fd);

    return 0;

exit_nu_adc_touch_writefile:

    return -1;
}

static void nu_touch_do_calibration(rt_device_t pdev)
{
    int i;
    rt_err_t result;

    S_CALIBRATION_MATRIX sCalMat;
    S_COORDINATE_POINT sADCPoints[DEF_CAL_POINT_NUM];

    lcd_device = rt_device_find("lcd");
    if (!lcd_device)
    {
        rt_kprintf("Not supported graphics ops\n");
        return;
    }

    result = rt_device_control(lcd_device, RTGRAPHIC_CTRL_GET_INFO, &info);
    if (result != RT_EOK)
    {
        rt_kprintf("error!");
        return;
    }

    result = rt_device_open(lcd_device, 0);
    if (result != RT_EOK)
    {
        rt_kprintf("opened?");
    }

    rt_device_control(lcd_device, RTGRAPHIC_CTRL_PAN_DISPLAY, info.framebuffer);
    rt_device_control(lcd_device, RTGRAPHIC_CTRL_POWERON, RT_NULL);

    for (i = 0; i < DEF_CAL_POINT_NUM; i++)
    {
        struct rt_touch_data sTouchPoint;
        int count = 0;

        lcd_cleanscreen();

        /* Drain RX queue before doing calibrate. */
        while (adc_request_point(pdev, &sTouchPoint) == RT_EOK);

        rt_thread_mdelay(100);

        /* Ready to calibrate */
        nu_draw_bots(sDispPoints[i].x, sDispPoints[i].y);

#define DEF_MAX_GET_POINT_NUM 5

        sADCPoints[i].x = 0;
        sADCPoints[i].y = 0;

        while (count < DEF_MAX_GET_POINT_NUM)
        {
            if (adc_request_point(pdev, &sTouchPoint) == RT_EOK)
            {
                sADCPoints[i].x += (int32_t)sTouchPoint.x_coordinate;
                sADCPoints[i].y += (int32_t)sTouchPoint.y_coordinate;
                rt_kprintf("[%d %d] - Disp:[%d, %d] -> ADC:[%d, %d]\n", i, count, sDispPoints[i].x, sDispPoints[i].y, sADCPoints[i].x, sADCPoints[i].y);
                count++;
            }
        }

        sADCPoints[i].x = (int32_t)((float)sADCPoints[i].x / DEF_MAX_GET_POINT_NUM);
        sADCPoints[i].y = (int32_t)((float)sADCPoints[i].y / DEF_MAX_GET_POINT_NUM);
        rt_kprintf("[%d] - Disp:[%d, %d], ADC:[%d, %d]\n", i, sDispPoints[i].x, sDispPoints[i].y, sADCPoints[i].x, sADCPoints[i].y);

        rt_thread_mdelay(300);
    }

    lcd_cleanscreen();

    /* Get calibration matrix. */
    if (nu_adc_cal_mat_get(&sDispPoints[0], &sADCPoints[0], &sCalMat) == 0)
    {
        /* Finally, update calibration matrix to drivers. */
        nu_adc_touch_update_calmat(&sCalMat);

        nu_adc_touch_writefile(&sCalMat, sizeof(sCalMat));

        for (i = 0; i < DEF_CAL_POINT_NUM; i++)
        {
            rt_kprintf("[%d] - Disp:[%d, %d], ADC:[%d, %d]\n", i, sDispPoints[i].x, sDispPoints[i].y, sADCPoints[i].x, sADCPoints[i].y);
        }
    }
    else
    {
        rt_kprintf("Failed to calibrate.\n");
    }

    rt_device_control(lcd_device, RTGRAPHIC_CTRL_POWEROFF, RT_NULL);
    rt_device_close(lcd_device);

    return;
}

static void adc_touch_entry(void *parameter)
{
    struct rt_touch_data touch_point;

    rt_err_t result;
    rt_device_t pdev;
    int max_range;

    adc_touch_sem = rt_sem_create("adc_touch_sem", 0, RT_IPC_FLAG_FIFO);
    RT_ASSERT(adc_touch_sem != RT_NULL);

    pdev = rt_device_find("adc_touch");
    if (!pdev)
    {
        rt_kprintf("Not found\n");
        return ;
    }

    if (rt_memcmp((void *)&g_sCalMat, (void *)&g_sCalZero, sizeof(S_CALIBRATION_MATRIX)) != 0)
        g_u32Calibrated = 1;

    nu_adc_touch_readfile();

    result = rt_device_open(pdev, RT_DEVICE_FLAG_INT_RX);
    RT_ASSERT(result == RT_EOK);

    result = rt_device_set_rx_indicate(pdev, adc_touch_rx_callback);
    RT_ASSERT(result == RT_EOK);

    max_range = BSP_LCD_WIDTH;
    result = rt_device_control(pdev, RT_TOUCH_CTRL_SET_X_RANGE, (void *)&max_range);
    RT_ASSERT(result == RT_EOK);

    max_range = BSP_LCD_HEIGHT;
    result = rt_device_control(pdev, RT_TOUCH_CTRL_SET_Y_RANGE, (void *)&max_range);
    RT_ASSERT(result == RT_EOK);

    result = rt_device_control(pdev, RT_TOUCH_CTRL_POWER_ON, RT_NULL);
    RT_ASSERT(result == RT_EOK);

    while (adc_touch_worker_run)
    {
        if (!g_u32Calibrated)
        {
            rt_kprintf("Start ADC touching calibration.\n");
            nu_touch_do_calibration(pdev);
            rt_kprintf("Stop ADC touching calibration.\n");
            continue;
        }

        if (adc_request_point(pdev, &touch_point) == RT_EOK)
        {
            if (touch_point.event == RT_TOUCH_EVENT_DOWN
                    || touch_point.event == RT_TOUCH_EVENT_UP
                    || touch_point.event == RT_TOUCH_EVENT_MOVE)
            {
                nu_touch_inputevent_cb(touch_point.x_coordinate, touch_point.y_coordinate, touch_point.event);

                rt_kprintf("x=%d y=%d event=%s%s%s\n",
                           touch_point.x_coordinate,
                           touch_point.y_coordinate,
                           (touch_point.event == RT_TOUCH_EVENT_DOWN) ? "DOWN" : "",
                           (touch_point.event == RT_TOUCH_EVENT_UP) ? "UP" : "",
                           (touch_point.event == RT_TOUCH_EVENT_MOVE) ? "MOVE" : "");
            }
        }
    }

    result = rt_device_control(pdev, RT_TOUCH_CTRL_POWER_OFF, RT_NULL);
    RT_ASSERT(result == RT_EOK);

    result = rt_device_close(pdev);
    RT_ASSERT(result == RT_EOK);
}


/* Support "nu_touch_start" command line in msh mode */
static rt_err_t nu_touch_start(int argc, char **argv)
{
    if (adc_touch_thread == RT_NULL)
    {
        adc_touch_thread = rt_thread_create("adc_touch_thread",
                                            adc_touch_entry,
                                            RT_NULL,
                                            2048,
                                            5,
                                            5);
        adc_touch_worker_run = 1;
        if (adc_touch_thread != RT_NULL)
            rt_thread_startup(adc_touch_thread);
    }
    return 0;
}
MSH_CMD_EXPORT(nu_touch_start, e.g: start adc touch);

/* Support "nu_touch_stop" command line in msh mode */
static rt_err_t nu_touch_stop(int argc, char **argv)
{
    adc_touch_worker_run = 0;
    adc_touch_thread = RT_NULL;
    return 0;
}
MSH_CMD_EXPORT(nu_touch_stop, e.g: stop adc touch);

static int nu_touch_autostart(void)
{
    return nu_touch_start(0, RT_NULL);
}
INIT_APP_EXPORT(nu_touch_autostart);

static rt_err_t nu_touch_calibration(int argc, char **argv)
{
    /* Clean calibration matrix data for getting raw adc value. */
    nu_adc_touch_reset_calmat();

    return 0;
}
MSH_CMD_EXPORT(nu_touch_calibration, for adc touch);

#endif //#if defined(NU_PKG_USING_ADC_TOUCH)