libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/ls1cdev/drivers/touch.c

608 lines
19 KiB
C
Raw Normal View History

[bsp] Add SmartloongV3 display,touch,msd, hw_i2c driver
2018-01-15 14:56:48 +08:00
/*
* File : touch.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Change Logs:
* Date Author Notes
* 2017-12-30 Sundm75 first version
*/
#include <stdbool.h>
#include <drivers/spi.h>
#include "ls1c.h"
#include "ls1c_gpio.h"
#include "ls1c_spi.h"
#include "drv_spi.h"
#include "touch.h"
#include <rtgui/calibration.h>
#include <rtthread.h>
#include <rtdevice.h>
#include <rtgui/event.h>
#include <rtgui/kbddef.h>
#include <rtgui/rtgui_server.h>
#include <rtgui/rtgui_system.h>
//<2F><><EFBFBD><EFBFBD>Ļ <20><><EFBFBD><EFBFBD>Ҫ _ILI_HORIZONTAL_DIRECTION_
//<2F><><EFBFBD><EFBFBD>Ļ <20><>Ҫ _ILI_HORIZONTAL_DIRECTION_
//#define _ILI_HORIZONTAL_DIRECTION_
#if defined(_ILI_HORIZONTAL_DIRECTION_)
#define X_WIDTH 272
#define Y_WIDTH 480
#else
#define X_WIDTH 480
#define Y_WIDTH 272
#endif
/*
TOUCH INT: 84
*/
#define IS_TOUCH_UP() gpio_get(TOUCH_INT_PIN)
#define led_gpio 52 // led1ָʾ
#define DUMMY 0x00
/*
7 6 - 4 3 2 1-0
s A2-A0 MODE SER/DFR PD1-PD0
*/
/* bit[1:0] power-down */
#define POWER_MODE0 (0) /* Power-Down Between Conversions. When */
/* each conversion is finished, the converter */
/* enters a low-power mode. At the start of the */
/* next conversion, the device instantly powers up */
/* to full power. There is no need for additional */
/* delays to ensure full operation, and the very first */
/* conversion is valid. The Y? switch is on when in */
/* power-down.*/
#define POWER_MODE1 (1) /* Reference is off and ADC is on. */
#define POWER_MODE2 (2) /* Reference is on and ADC is off. */
#define POWER_MODE3 (3) /* Device is always powered. Reference is on and */
/* ADC is on. */
/* bit[2] SER/DFR */
#define DIFFERENTIAL (0<<2)
#define SINGLE_ENDED (1<<2)
/* bit[3] mode */
#define MODE_12BIT (0<<3)
#define MODE_8BIT (1<<3)
/* bit[6:4] differential mode */
#define MEASURE_X (((1<<2) | (0<<1) | (1<<0))<<4)
#define MEASURE_Y (((0<<2) | (0<<1) | (1<<0))<<4)
#define MEASURE_Z1 (((0<<2) | (1<<1) | (1<<0))<<4)
#define MEASURE_Z2 (((1<<2) | (0<<1) | (0<<0))<<4)
/* bit[7] start */
#define START (1<<7)
/* X Y change. */
#define TOUCH_MSR_X (START | MEASURE_X | MODE_12BIT | DIFFERENTIAL | POWER_MODE0)
#define TOUCH_MSR_Y (START | MEASURE_Y | MODE_12BIT | DIFFERENTIAL | POWER_MODE0)
/* <20><><EFBFBD><EFBFBD><C2B6><EFBFBD>XPT2046 <20>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD><CEBB>*/
#if defined(_ILI_HORIZONTAL_DIRECTION_)
#define MIN_X_DEFAULT 2047
#define MAX_X_DEFAULT 47
#define MIN_Y_DEFAULT 102
#define MAX_Y_DEFAULT 1939
#else
#define MIN_X_DEFAULT 47
#define MAX_X_DEFAULT 2047
#define MIN_Y_DEFAULT 1939
#define MAX_Y_DEFAULT 102
#endif
#define SAMP_CNT 8 //the adc array size
#define SAMP_CNT_DIV2 4 //the middle of the adc array
#define SH 10 // Valve value
/*<2A>궨<EFBFBD><EAB6A8> */
#define TOUCH_SPI_X SPI1
#define TOUCH_INT_PIN 84
#define TOUCH_CS_PIN 49
#define TOUCH_SCK_PIN 46
#define TOUCH_MISO_PIN 47
#define TOUCH_MOSI_PIN 48
/*<2A><><EFBFBD><EFBFBD><EFBFBD>ṹ<EFBFBD>彫<EFBFBD><E5BDAB>Ҫ<EFBFBD>õ<EFBFBD><C3B5>Ķ<EFBFBD><C4B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD><D0B4><EFBFBD>*/
struct rtgui_touch_device
{
struct rt_device parent; /* <20><><EFBFBD><EFBFBD>ע<EFBFBD><D7A2><EFBFBD>豸*/
rt_uint16_t x, y; /* <20><>¼<EFBFBD><C2BC>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>λ<EFBFBD><CEBB>ֵ */
rt_bool_t calibrating; /* <20><><EFBFBD><EFBFBD>У׼<D0A3><D7BC>־ */
rt_touch_calibration_func_t calibration_func;/* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8> */
rt_uint16_t min_x, max_x; /* У׼<D0A3><D7BC> X <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С <20><><EFBFBD><EFBFBD>ֵ */
rt_uint16_t min_y, max_y; /* У׼<D0A3><D7BC> Y <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С <20><><EFBFBD><EFBFBD>ֵ */
struct rt_spi_device * spi_device; /* SPI <20>豸 <20><><EFBFBD><EFBFBD>ͨ<EFBFBD><CDA8> */
struct rt_event event; /* <20>¼<EFBFBD>ͬ<EFBFBD><CDAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڡ<EFBFBD><DAA1><EFBFBD><EFBFBD>жϡ<D0B6> */
};
static struct rtgui_touch_device *touch = RT_NULL;
static rt_err_t touch_send_then_recv(struct rt_spi_device *device,
const void *send_buf,
rt_size_t send_length,
void *recv_buf,
rt_size_t recv_length)
{
rt_err_t result;
struct rt_spi_message message;
rt_uint8_t dummy[128] ;
rt_memset(dummy, DUMMY, sizeof(dummy));
RT_ASSERT(device != RT_NULL);
RT_ASSERT(device->bus != RT_NULL);
result = rt_mutex_take(&(device->bus->lock), RT_WAITING_FOREVER);
if (result == RT_EOK)
{
if (device->bus->owner != device)
{
/* not the same owner as current, re-configure SPI bus */
result = device->bus->ops->configure(device, &device->config);
if (result == RT_EOK)
{
/* set SPI bus owner */
device->bus->owner = device;
}
else
{
/* configure SPI bus failed */
result = -RT_EIO;
goto __exit;
}
}
/* send data */
message.send_buf = send_buf;
message.recv_buf = RT_NULL;
message.length = send_length;
message.cs_take = 1;
message.cs_release = 0;
message.next = RT_NULL;
result = device->bus->ops->xfer(device, &message);
if (result == 0)
{
result = -RT_EIO;
goto __exit;
}
/* recv data */
message.send_buf = dummy;
message.recv_buf = recv_buf;
message.length = recv_length;
message.cs_take = 0;
message.cs_release = 1;
message.next = RT_NULL;
result = device->bus->ops->xfer(device, &message);
if (result == 0)
{
result = -RT_EIO;
goto __exit;
}
result = RT_EOK;
}
else
{
return -RT_EIO;
}
__exit:
rt_mutex_release(&(device->bus->lock));
return result;
}
static void rtgui_touch_calculate(void)
{
if (touch != RT_NULL)
{
/* read touch */
{
rt_uint8_t i, j, k, min;
rt_uint16_t temp;
rt_uint16_t tmpxy[2][SAMP_CNT];
rt_uint8_t send_buffer[1];
rt_uint8_t recv_buffer[2];
for(i=0; i<SAMP_CNT; i++)
{
send_buffer[0] = TOUCH_MSR_X;
touch_send_then_recv(touch->spi_device, send_buffer, 1, recv_buffer, 2);
rt_kprintf("touch x: %d ",(recv_buffer[0]*256|recv_buffer[1])>>4);
#if defined(_ILI_HORIZONTAL_DIRECTION_)
tmpxy[1][i] = (recv_buffer[0]<<8)|recv_buffer[1] ;
tmpxy[1][i] >>= 4;
#else
tmpxy[0][i] = (recv_buffer[0]<<8)|recv_buffer[1] ;
tmpxy[0][i] >>=4;
#endif
send_buffer[0] = TOUCH_MSR_Y;
touch_send_then_recv(touch->spi_device, send_buffer, 1, recv_buffer, 2);
rt_kprintf("touch y: %d \n",(recv_buffer[0]*256|recv_buffer[1])>>4);
#if defined(_ILI_HORIZONTAL_DIRECTION_)
tmpxy[0][i] = (recv_buffer[0]<<8)|recv_buffer[1] ;
tmpxy[0][i] >>= 4;
#else
tmpxy[1][i] = (recv_buffer[0]<<8)|recv_buffer[1] ;
tmpxy[1][i] >>= 4;
#endif
}
/*<2A>ٴδ򿪴<CEB4><F2BFAAB4><EFBFBD><EFBFBD>ж<EFBFBD>*/
send_buffer[0] = 1 << 7;
touch_send_then_recv(touch->spi_device, send_buffer, 1, recv_buffer, 2);
touch_send_then_recv(touch->spi_device, send_buffer, 1, recv_buffer, 2);
/* calculate average */
{
rt_uint32_t total_x = 0;
rt_uint32_t total_y = 0;
for(k=0; k<2; k++)
{
// sorting the ADC value
for(i=0; i<SAMP_CNT-1; i++)
{
min=i;
for (j=i+1; j<SAMP_CNT; j++)
{
if (tmpxy[k][min] > tmpxy[k][j])
min=j;
}
temp = tmpxy[k][i];
tmpxy[k][i] = tmpxy[k][min];
tmpxy[k][min] = temp;
}
//check value for Valve value
if((tmpxy[k][SAMP_CNT_DIV2+1]-tmpxy[k][SAMP_CNT_DIV2-2]) > SH)
{
return;
}
}
total_x=tmpxy[0][SAMP_CNT_DIV2-2]+tmpxy[0][SAMP_CNT_DIV2-1]+tmpxy[0][SAMP_CNT_DIV2]+tmpxy[0][SAMP_CNT_DIV2+1];
total_y=tmpxy[1][SAMP_CNT_DIV2-2]+tmpxy[1][SAMP_CNT_DIV2-1]+tmpxy[1][SAMP_CNT_DIV2]+tmpxy[1][SAMP_CNT_DIV2+1];
//calculate average value
touch->x=total_x>>2;
touch->y=total_y>>2;
rt_kprintf("touch->x:%d touch->y:%d\r\n", touch->x, touch->y);
} /* calculate average */
} /* read touch */
/* if it's not in calibration status */
/*<2A><><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD>*/
if (touch->calibrating != RT_TRUE)
{
if (touch->max_x > touch->min_x)
{
touch->x = (touch->x - touch->min_x) * X_WIDTH/(touch->max_x - touch->min_x);
}
else
{
touch->x = (touch->min_x - touch->x) * X_WIDTH/(touch->min_x - touch->max_x);
}
if (touch->max_y > touch->min_y)
{
touch->y = (touch->y - touch->min_y) * Y_WIDTH /(touch->max_y - touch->min_y);
}
else
{
touch->y = (touch->min_y - touch->y) * Y_WIDTH /(touch->min_y - touch->max_y);
}
}
}
}
#include "ls1c_regs.h"
#define TOUCH_INT_EN __REG32(LS1C_INT4_EN)
rt_inline void touch_int_cmd(rt_bool_t NewState)
{
if(NewState == RT_TRUE)
{
//TOUCH_INT_EN |= (1<<(TOUCH_INT_PIN-64));
reg_set_one_bit(LS1C_INT4_EN, 1<<(TOUCH_INT_PIN-64));
}
else
{
//TOUCH_INT_EN &=(~ (1<<(TOUCH_INT_PIN-64)));
reg_clr_one_bit(LS1C_INT4_EN, 1<<(TOUCH_INT_PIN-64));
}
}
void ls1c_touch_irqhandler(void) /* TouchScreen */
{
if(gpio_get(TOUCH_INT_PIN)==0)
{
/* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>º<EFBFBD><C2BA><EFBFBD><EFBFBD><EFBFBD> */
if (gpio_level_low == gpio_get(led_gpio))
gpio_set(led_gpio, gpio_level_high);
else
gpio_set(led_gpio, gpio_level_low);
touch_int_cmd(RT_FALSE);
rt_event_send(&touch->event, 1);
}
}
/*<2A>ܽų<DCBD>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>жϴ<D0B6><CFB4><EFBFBD>SPI1 CS0 <20>豸*/
rt_inline void touch_init(void)
{
unsigned int touch_int_gpio = TOUCH_INT_PIN; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD>
int touch_irq = LS1C_GPIO_TO_IRQ(touch_int_gpio);
// <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD>
gpio_set_irq_type(touch_int_gpio, IRQ_TYPE_EDGE_FALLING);
rt_hw_interrupt_install(touch_irq, ls1c_touch_irqhandler, RT_NULL, "touch");
rt_hw_interrupt_umask(touch_irq);
gpio_init(touch_int_gpio, gpio_mode_input);
// <20><>ʼ<EFBFBD><CABC>led
gpio_init(led_gpio, gpio_mode_output);
gpio_set(led_gpio, gpio_level_high);
}
/* RT-Thread Device Interface */
static rt_err_t rtgui_touch_init (rt_device_t dev)
{
rt_uint8_t send;
rt_uint8_t recv_buffer[2];
struct rtgui_touch_device * touch_device = (struct rtgui_touch_device *)dev;
touch_init();
rt_kprintf("touch_init ...\n");
send = START | DIFFERENTIAL | POWER_MODE0;
touch_send_then_recv(touch->spi_device, &send, 1, recv_buffer, 2);
return RT_EOK;
}
static rt_err_t rtgui_touch_control (rt_device_t dev, int cmd, void *args)
{
switch (cmd)
{
case RT_TOUCH_CALIBRATION:
touch->calibrating = RT_TRUE;
touch->calibration_func = (rt_touch_calibration_func_t)args;
break;
case RT_TOUCH_NORMAL:
touch->calibrating = RT_FALSE;
break;
case RT_TOUCH_CALIBRATION_DATA:
{
struct calibration_data* data;
data = (struct calibration_data*) args;
//update
touch->min_x = data->min_x;
touch->max_x = data->max_x;
touch->min_y = data->min_y;
touch->max_y = data->max_y;
}
break;
}
return RT_EOK;
}
void _set_mouse_position(rt_uint32_t X, rt_uint32_t Y)
{}
static void touch_thread_entry(void *parameter)
{
rt_bool_t touch_down = RT_FALSE;
rt_uint32_t event_value;
struct rtgui_event_mouse emouse;
static struct _touch_previous
{
rt_uint32_t x;
rt_uint32_t y;
} touch_previous;
RTGUI_EVENT_MOUSE_BUTTON_INIT(&emouse);
emouse.wid = RT_NULL;
while(1)
{
/* <20><><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD><D0B6>¼<EFBFBD> */
if(rt_event_recv(&touch->event,
1,
RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
100,
&event_value)
== RT_EOK)
{
while(1)
{
if (IS_TOUCH_UP())
{
/* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̧<EFBFBD><CCA7> */
/* touch up */
emouse.button = (RTGUI_MOUSE_BUTTON_LEFT |RTGUI_MOUSE_BUTTON_UP);
/* use old value */
emouse.x = touch->x;
emouse.y = touch->y;
if(touch_down != RT_TRUE)
{
touch_int_cmd(RT_TRUE);
break;
}
if ((touch->calibrating == RT_TRUE) && (touch->calibration_func != RT_NULL))
{
/* <20><><EFBFBD><EFBFBD>У׼<D0A3><D7BC><EFBFBD><EFBFBD> */
/* callback function */
touch->calibration_func(emouse.x, emouse.y);
}
else
{
/* <20><>ui<75><69><EFBFBD>ʹ<EFBFBD><CDB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
rtgui_server_post_event(&emouse.parent, sizeof(struct rtgui_event_mouse));
}
rt_kprintf("touch up: (%d, %d)\n", emouse.x, emouse.y);
/* clean */
touch_previous.x = touch_previous.y = 0;
touch_down = RT_FALSE;
touch_int_cmd(RT_TRUE);
break;
} /* touch up */
else /* touch down or move */
{
if(touch_down == RT_FALSE)
{
rt_thread_delay(RT_TICK_PER_SECOND / 10);
}
else
{
rt_thread_delay(5);
}
if(IS_TOUCH_UP()) continue;
/* calculation */
rtgui_touch_calculate();
/* send mouse event */
emouse.parent.type = RTGUI_EVENT_MOUSE_BUTTON;
emouse.parent.sender = RT_NULL;
emouse.x = touch->x;
emouse.y = touch->y;
_set_mouse_position(emouse.x, emouse.y);
/* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
/* init mouse button */
emouse.button = (RTGUI_MOUSE_BUTTON_LEFT |RTGUI_MOUSE_BUTTON_DOWN);
/* send event to server */
if (touch->calibrating != RT_TRUE)
{
#define previous_keep 8
/* filter. */
if((touch_previous.x > touch->x + previous_keep)
|| (touch_previous.x < touch->x - previous_keep)
|| (touch_previous.y > touch->y + previous_keep)
|| (touch_previous.y < touch->y - previous_keep))
{
touch_previous.x = touch->x;
touch_previous.y = touch->y;
/* <20><>ui<75><69><EFBFBD>ʹ<EFBFBD><CDB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
rtgui_server_post_event(&emouse.parent, sizeof(struct rtgui_event_mouse));
if(touch_down == RT_FALSE)
{
touch_down = RT_TRUE;
rt_kprintf("touch down: (%d, %d)\n", emouse.x, emouse.y);
}
else
{
rt_kprintf("touch motion: (%d, %d)\n", emouse.x, emouse.y);
}
}
}
else
{
touch_down = RT_TRUE;
}
} /* touch down or move */
} /* read touch */
} /* event recv */
} /* thread while(1) */
}
rt_err_t rtgui_touch_hw_init(const char * spi_device_name)
{
rt_uint32_t arg[2];
struct rt_device * spi_device;
struct rt_thread * touch_thread;
rt_err_t err;
rt_kprintf("spi1 cs0 start...\n");
spi_device = rt_device_find("spi10");
if(spi_device == RT_NULL)
{
rt_kprintf("Did not find spi1, exit thread....\n");
return;
}
err = rt_device_open(spi_device, RT_DEVICE_OFLAG_RDWR);
if(err != RT_EOK)
{
rt_kprintf("Open spi1 failed %08X, exit thread....\n", err);
return;
}
/* config spi */
{
struct rt_spi_configuration cfg;
cfg.data_width = 8;
cfg.mode = RT_SPI_MODE_0;
cfg.max_hz = 200 * 1000; /* 200K */
rt_spi_configure((struct rt_spi_device *)spi_device, &cfg);
}
touch = (struct rtgui_touch_device*)rt_malloc (sizeof(struct rtgui_touch_device));
if (touch == RT_NULL) return RT_ENOMEM; /* no memory yet */
/* clear device structure */
rt_memset(&(touch->parent), 0, sizeof(struct rt_device));
rt_event_init(&touch->event, "touch", RT_IPC_FLAG_FIFO);
touch->spi_device = (struct rt_spi_device *)spi_device;
touch->calibrating = false;
touch->min_x = MIN_X_DEFAULT;
touch->max_x = MAX_X_DEFAULT;
touch->min_y = MIN_Y_DEFAULT;
touch->max_y = MAX_Y_DEFAULT;
/* init device structure */
touch->parent.type = RT_Device_Class_Miscellaneous;
touch->parent.init = rtgui_touch_init;
touch->parent.control = rtgui_touch_control;
touch->parent.user_data = RT_NULL;
/* register touch device to RT-Thread */
rt_device_register(&(touch->parent), "touch", RT_DEVICE_FLAG_RDWR);
touch_thread = rt_thread_create("touch_thread",
touch_thread_entry, RT_NULL,
4096, RTGUI_SVR_THREAD_PRIORITY-1, 1);
if (touch_thread != RT_NULL) rt_thread_startup(touch_thread);
rt_device_init((rt_device_t)touch);
return RT_EOK;
}