piotr/edgetx-gx12
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

New touch driver for NV14 implemented.

Browse Source 
Backlight always enabled for NV14.
SDRAM init fixed for NV14.
This commit is contained in:
Jakub
2019-09-01 23:11:09 +02:00
parent 340dfbc538
commit 1c81618262
6 changed files with 868 additions and 422 deletions
Download Patch File Download Diff File Expand all files Collapse all files
radio/src/targets/nv14/backlight_driver.cpp
+3 -1
View File
@@ -45,5 +45,7 @@ void backlightInit()
void backlightEnable(uint8_t dutyCycle)
{
BACKLIGHT_TIMER->CCR1 = dutyCycle;
// TODO SET provided cycle - for now ensure backlight will be on
//BACKLIGHT_TIMER->CCR1 = dutyCycle;
BACKLIGHT_TIMER->CCR1 = BACKLIGHT_LEVEL_MAX;
}
radio/src/targets/nv14/board.cpp
-1
View File
@@ -85,7 +85,6 @@ void interrupt1ms()
if (pre_scale == 10) {
pre_scale = 0;
#if !defined(SIMU)
TouchDriver();
hall_stick_loop();
#endif
DEBUG_TIMER_START(debugTimerPer10ms);
radio/src/targets/nv14/lcd_driver.cpp
+44
View File
@@ -41,6 +41,50 @@ static void LCD_Delay( void )
}
}
enum ENUM_IO_SPEED
{
IO_SPEED_LOW,
IO_SPEED_MID,
IO_SPEED_QUICK,
IO_SPEED_HIGH
};
enum ENUM_IO_MODE
{
IO_MODE_INPUT,
IO_MODE_OUTPUT,
IO_MODE_ALTERNATE,
IO_MODE_ANALOG
};
void GPIO_SetDirection( GPIO_TypeDef *GPIOx, unsigned char Pin, unsigned char IsInput )
{
unsigned int Mask;
unsigned int Position;
unsigned int Register;
Position = Pin << 1;
Mask = ~( 0x03UL << Position );
//EnterCritical();
Register = GPIOx->OSPEEDR & Mask;
Register |= IO_SPEED_HIGH << Position;
GPIOx->OSPEEDR = Register;
//ExitCritical();
//EnterCritical();
Register = GPIOx->MODER & Mask;
if( !IsInput )
{
Register |= IO_MODE_OUTPUT << Position;
}
GPIOx->MODER = Register;
//ExitCritical();
}
static void LCD_AF_GPIOConfig(void)
{
/*
radio/src/targets/nv14/sdram_driver.c
+3 -1
View File
@@ -203,7 +203,9 @@ void SDRAM_InitSequence(void)
void SDRAM_Init(void)
{
// Clocks must be enabled here, because the SDRAM_Init() is called before main
//delay funcion needed
delaysInit();
// Clocks must be enabled here, because the sdramInit is called before main
RCC_AHB1PeriphClockCmd(SDRAM_RCC_AHB1Periph, ENABLE);
RCC_AHB3PeriphClockCmd(SDRAM_RCC_AHB3Periph, ENABLE);
radio/src/targets/nv14/touch_driver.cpp
+523 -373
View File
@@ -25,408 +25,558 @@ enum ENUM_TOUCH_STATE
TOUCH_SLIDE,
TOUCH_CLICK
};
#define TOUCH_DELAY() TouchDelay()
void GPIO_SetDirection( GPIO_TypeDef *GPIOx, unsigned char Pin, unsigned char IsInput )
{
unsigned int Mask;
unsigned int Position;
unsigned int Register;
Position = Pin << 1;
Mask = ~( 0x03UL << Position );
//EnterCritical();
Register = GPIOx->OSPEEDR & Mask;
Register |= IO_SPEED_HIGH << Position;
GPIOx->OSPEEDR = Register;
//ExitCritical();
//EnterCritical();
Register = GPIOx->MODER & Mask;
if( !IsInput )
{
Register |= IO_MODE_OUTPUT << Position;
}
GPIOx->MODER = Register;
//ExitCritical();
}
/*==================================================================================================
Name:
Function:
Input:
Output:
==================================================================================================*/
void TouchInit( void )
{
SET_TOUCH_RESET_OUT();
CLR_TOUCH_RESET();
SET_TOUCH_SCL_OUT();
SET_TOUCH_SDA_OUT();
SET_TOUCH_SCL();
SET_TOUCH_SDA();
SET_TOUCH_INT_IN();
}
/*==================================================================================================
Name:
Function:
Input:
Output:
==================================================================================================*/
static void TouchConditionDelay( void )
{
volatile unsigned int i;
for( i = 0; i < 40; i++ )
{
;
}
}
/*==================================================================================================
Name:
Function:
Input:
Output:
==================================================================================================*/
static void TouchDelay( void )
{
volatile unsigned int i;
for( i = 0; i < 3; i++ )
{
;
}
}
/*==================================================================================================
Name:
Function:
Input:
Output:
==================================================================================================*/
static void TouchStart( void )
{
SET_TOUCH_SCL_OUT();
SET_TOUCH_SDA_OUT();
SET_TOUCH_SCL();
SET_TOUCH_SDA();
TouchConditionDelay();
CLR_TOUCH_SDA();
TouchConditionDelay();
CLR_TOUCH_SCL();
TOUCH_DELAY();
}
/*==================================================================================================
Name:
Function:
Input:
Output:
==================================================================================================*/
static void TouchStop( void )
{
CLR_TOUCH_SCL();
TOUCH_DELAY();
CLR_TOUCH_SDA();
SET_TOUCH_SCL();
TouchConditionDelay();
SET_TOUCH_SDA();
TouchConditionDelay();
}
/*==================================================================================================
Name:
Function:
Input:
Output:
==================================================================================================*/
static void SendAckToTouch( unsigned char Ack )
{
if( Ack )
{
SET_TOUCH_SDA();
}
else
{
CLR_TOUCH_SDA();
}
SET_TOUCH_SCL();
TOUCH_DELAY();
CLR_TOUCH_SCL();
TOUCH_DELAY();
}
/*==================================================================================================
Name:
Function:
Input:
Output:
==================================================================================================*/
static unsigned char GetTouchAck( void )
{
unsigned char i;
SET_TOUCH_SDA();
SET_TOUCH_SDA_IN();
SET_TOUCH_SCL();
TOUCH_DELAY();
if( READ_TOUCH_SDA() )
{
i = 1;
}
else
{
i = 0;
}
CLR_TOUCH_SCL();
SET_TOUCH_SDA_OUT();
return( i );
}
/*==================================================================================================
Name:
Function:
Input:
Output:
==================================================================================================*/
unsigned char ReceiveByteFromTouch( void )
{
unsigned char i;
unsigned char ucReceive = 0;
SET_TOUCH_SDA_IN();
for( i = 0; i < 8; i++ )
{
CLR_TOUCH_SCL();
TOUCH_DELAY();
ucReceive <<= 1;
SET_TOUCH_SCL();
TOUCH_DELAY();
if( READ_TOUCH_SDA() )
{
ucReceive |= 0x01;
}
}
CLR_TOUCH_SCL();
SET_TOUCH_SDA_OUT();
TOUCH_DELAY();
return( ucReceive );
}
/*==================================================================================================
Name:
Function:
Input:
Output:
==================================================================================================*/
static void SendByteToTouch( unsigned char ucSendData )
{
unsigned char i;
for( i = 0; i < 8; i++ )
{
CLR_TOUCH_SCL();
TOUCH_DELAY();
if( ucSendData & 0x80 )
{
SET_TOUCH_SDA();
}
else
{
CLR_TOUCH_SDA();
}
SET_TOUCH_SCL();
ucSendData <<= 1;
TOUCH_DELAY();
}
CLR_TOUCH_SCL();
TOUCH_DELAY();
}
/*==================================================================================================
Name:
Function:
Input:
Output:
==================================================================================================*/
unsigned char ReadTouchData( unsigned char *pData, unsigned char Length )
{
unsigned char ucTryCount;
#if 1
ucTryCount = 0;
while( ucTryCount < 3 )
{
do
{
TouchStart();
SendByteToTouch( ( TOUCH_PANEL_ADDRESS << 1 )|0x00 );
if( GetTouchAck() )
{
break;
}
SendByteToTouch( 0x00 );
if( GetTouchAck() )
{
break;
}
TouchStart();
SendByteToTouch( ( TOUCH_PANEL_ADDRESS << 1 )|0x01 );
if( GetTouchAck() )
{
break;
}
while( Length )
{
*pData = ReceiveByteFromTouch();
Length--;
pData++;
if( 0 != Length )
{
SendAckToTouch( 0 );
}
else
{
SendAckToTouch( 1 );
}
}
TouchStop();
return( !0 );
}while( 0 );
ucTryCount++;
TouchStop();
}
#endif
return( 0 );
}
signed int x;
signed int y;
unsigned char TouchEvent;
unsigned char TouchBuffer[7];
uint32_t TouchEvent;
unsigned short Tx;
unsigned short Ty;
extern STRUCT_TOUCH touchState; //definition in mainwindow.cpp
static unsigned char TouchCycle = 0;
static unsigned char TouchState = TOUCH_NONE;
static unsigned short Txold;
static unsigned short Tyold;
static unsigned short TouchStartX;
static unsigned short TouchStartY;
void TouchDriver( void )
#include "ft6x06.h"
#include "STM32F4xx_DSP_StdPeriph_Lib_V1.4.0/Libraries/STM32F4xx_StdPeriph_Driver/inc/stm32f4xx_i2c.h"
#define FT6x06_MAX_INSTANCE 1
#define I2C_TOUCH_RCC_AHB1Periph RCC_AHB1Periph_GPIOB
#define I2C_TOUCH_RCC_APB1Periph RCC_APB1Periph_I2C1
#define I2C_TOUCH I2C1
#define I2C_TOUCH_GPIO GPIOB
#define I2C_TOUCH_SCL_GPIO_PIN GPIO_Pin_8 // PB.08
#define I2C_TOUCH_SDA_GPIO_PIN GPIO_Pin_7 // PB.09
#define I2C_TOUCH_RESET_GPIO GPIOB
#define I2C_TOUCH_RESET_GPIO_PIN GPIO_Pin_12 // PB.12
#define I2C_TOUCH_INT_GPIO GPIOB
#define I2C_TOUCH_INT_GPIO_PIN GPIO_Pin_9 // PB.09
#define TOUCH_FT6236_I2C_ADDRESS (0x70>>1)
uint8_t ft6x06[FT6x06_MAX_INSTANCE] = { 0 };
static ft6x06_handle_TypeDef ft6x06_handle = { FT6206_I2C_NOT_INITIALIZED, 0, 0};
static void I2C_FreeBus(void) {
GPIO_InitTypeDef GPIO_InitStructure;
// reset i2c bus by setting clk as output and sending manual clock pulses
GPIO_InitStructure.GPIO_Pin = I2C_TOUCH_SCL_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(I2C_TOUCH_GPIO, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = I2C_TOUCH_SDA_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(I2C_TOUCH_GPIO, &GPIO_InitStructure);
//send 100khz clock train for some 100ms
tmr10ms_t until = get_tmr10ms() + 11;
while(get_tmr10ms() < until){
if (GPIO_ReadInputDataBit(I2C_TOUCH_GPIO, I2C_TOUCH_SDA_GPIO_PIN) == 1){
TRACE("touch: i2c free again\n");
break;
}
TRACE("FREEEEE");
I2C_TOUCH_GPIO->BSRRH = I2C_TOUCH_SCL_GPIO_PIN; //BSRRL
delay_us(10);
I2C_TOUCH_GPIO->BSRRL = I2C_TOUCH_SCL_GPIO_PIN;
delay_us(10);
}
//send stop condition:
GPIO_InitStructure.GPIO_Pin = I2C_TOUCH_SDA_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(I2C_TOUCH_GPIO, &GPIO_InitStructure);
//clock is low
I2C_TOUCH_GPIO->BSRRH = I2C_TOUCH_SCL_GPIO_PIN;
delay_us(10);
//sda = lo
I2C_TOUCH_GPIO->BSRRL = I2C_TOUCH_SDA_GPIO_PIN;
delay_us(10);
//clock goes high
I2C_TOUCH_GPIO->BSRRH = I2C_TOUCH_SCL_GPIO_PIN;
delay_us(10);
//sda = hi
I2C_TOUCH_GPIO->BSRRL = I2C_TOUCH_SDA_GPIO_PIN;
delay_us(10);
TRACE("FREE BUS");
}
static void Touch_DeInit(void)
{
SET_TOUCH_RESET();
I2C_DeInit(I2C_TOUCH);
(RCC->APB1RSTR |= (RCC_APB1RSTR_I2C1RST));
delay_ms(150);
(RCC->APB1RSTR &= ~(RCC_APB1RSTR_I2C1RST));
}
TouchCycle++;
static void I2C_Init(void)
{
Touch_DeInit();
if( TouchCycle >= 1 )
GPIO_InitTypeDef GPIO_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
I2C_InitTypeDef I2C_InitStructure;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, ENABLE);
RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, DISABLE);
I2C_FreeBus();
GPIO_PinAFConfig(I2C_TOUCH_GPIO, GPIO_PinSource7, GPIO_AF_I2C1);
GPIO_PinAFConfig(I2C_TOUCH_GPIO, GPIO_PinSource8, GPIO_AF_I2C1);
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStructure.GPIO_Pin = I2C_TOUCH_SCL_GPIO_PIN | I2C_TOUCH_SDA_GPIO_PIN;
GPIO_Init(I2C_TOUCH_GPIO, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = I2C_TOUCH_RESET_GPIO_PIN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//GPIO_PuPd_NOPULL; //
GPIO_Init(I2C_TOUCH_RESET_GPIO, &GPIO_InitStructure);
//https://community.st.com/s/question/0D50X00009XkZ9FSAV/stm32f4-i2c-issues-solved
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
I2C_StructInit(&I2C_InitStructure);
I2C_InitStructure.I2C_ClockSpeed = 400000;
I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
I2C_Init(I2C_TOUCH, &I2C_InitStructure);
I2C_Init(I2C_TOUCH, &I2C_InitStructure);
//I2C_StretchClockCmd(I2C_TOUCH, ENABLE);
I2C_Cmd(I2C_TOUCH, ENABLE);
//ext interupt
GPIO_InitStructure.GPIO_Pin = I2C_TOUCH_INT_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(I2C_TOUCH_INT_GPIO, &GPIO_InitStructure);
SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOB, EXTI_PinSource9);
EXTI_InitStructure.EXTI_Line = EXTI_Line9;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 8;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
#define I2C_TIMEOUT_MAX 1000
bool I2C_WaitEvent(uint32_t event)
{
uint32_t timeout = I2C_TIMEOUT_MAX;
while (!I2C_CheckEvent(I2C_TOUCH, event)) {
if ((timeout--) == 0) return false;
}
return true;
}
bool I2C_WaitEventCleared(uint32_t event)
{
uint32_t timeout = I2C_TIMEOUT_MAX;
while (I2C_CheckEvent(I2C_TOUCH, event)) {
if ((timeout--) == 0) return false;
}
return true;
}
bool I2C_Send7BitAddress(uint8_t address, uint16_t direction){
I2C_SendData(I2C_TOUCH, (address << 1) | ((direction == I2C_Direction_Receiver) ? 1 : 0));
// check if slave acknowledged his address within timeout
if(!I2C_WaitEvent(direction == I2C_Direction_Transmitter ? I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED : I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED)) return false;
return true;
}
bool touch_i2c_read(uint8_t addr, uint8_t reg, uint8_t *data, uint8_t len){
if (!I2C_WaitEventCleared(I2C_FLAG_BUSY)) return false;
I2C_GenerateSTART(I2C_TOUCH, ENABLE);
if (!I2C_WaitEvent(I2C_EVENT_MASTER_MODE_SELECT)) return false;
if(!I2C_Send7BitAddress(addr, I2C_Direction_Transmitter)) return false;
I2C_SendData(I2C_TOUCH, reg);
if (!I2C_WaitEvent(I2C_EVENT_MASTER_BYTE_TRANSMITTED)) return false;
I2C_GenerateSTART(I2C_TOUCH, ENABLE);
if (!I2C_WaitEvent(I2C_EVENT_MASTER_MODE_SELECT)) return false;
if(!I2C_Send7BitAddress(addr, I2C_Direction_Receiver)) return false;
if (len > 1) I2C_AcknowledgeConfig(I2C_TOUCH, ENABLE);
while (len) {
if (len == 1) I2C_AcknowledgeConfig(I2C_TOUCH, DISABLE);
if (!I2C_WaitEvent(I2C_EVENT_MASTER_BYTE_RECEIVED))return false;
*data++ = I2C_ReceiveData(I2C_TOUCH);;
len--;
}
I2C_GenerateSTOP(I2C_TOUCH, ENABLE);
return true;
}
static bool touch_i2c_write(uint8_t addr, uint8_t reg, uint8_t *data, uint8_t len)
{
if (!I2C_WaitEventCleared(I2C_FLAG_BUSY)) return false;
I2C_GenerateSTART(I2C_TOUCH, ENABLE);
if (!I2C_WaitEvent(I2C_EVENT_MASTER_MODE_SELECT)) return false;
if(!I2C_Send7BitAddress(addr, I2C_Direction_Transmitter)) return false;
I2C_SendData(I2C_TOUCH, (uint8_t)((reg & 0xFF00) >> 8));
if (!I2C_WaitEvent(I2C_EVENT_MASTER_BYTE_TRANSMITTING)) return false;
I2C_SendData(I2C_TOUCH, (uint8_t)(reg & 0x00FF));
if (!I2C_WaitEvent(I2C_EVENT_MASTER_BYTE_TRANSMITTING)) return false;
while (len--) {
I2C_SendData(I2C_TOUCH, *data);
if (!I2C_WaitEvent(I2C_EVENT_MASTER_BYTE_TRANSMITTING)) return false;
data++;
}
if (!I2C_WaitEvent(I2C_EVENT_MASTER_BYTE_TRANSMITTED)) return false;
I2C_GenerateSTOP(I2C_TOUCH, ENABLE);
return true;
}
static void TS_IO_Write(uint8_t addr, uint8_t reg, uint8_t data)
{
uint8_t tryCount = 3;
while(!touch_i2c_write(addr, reg, &data, 1)) {
if(--tryCount == 0) break;
I2C_Init();
}
}
static uint8_t TS_IO_Read(uint8_t addr, uint8_t reg)
{
uint8_t retult;
uint8_t tryCount = 3;
while(!touch_i2c_read(addr, reg, &retult, 1)) {
if(--tryCount == 0) break;
I2C_Init();
}
return retult;
}
static uint16_t TS_IO_ReadMultiple(uint8_t addr, uint8_t reg, uint8_t *buffer, uint16_t length)
{
uint8_t tryCount = 3;
while(!touch_i2c_read(addr, reg, buffer, length)) {
if(--tryCount == 0) break;
I2C_Init();
}
return 1;
}
static uint8_t TS_IO_Read(uint8_t reg) {
return TS_IO_Read(TOUCH_FT6236_I2C_ADDRESS, reg);
}
static void touch_ft6236_debug_info(void) {
#if defined(DEBUG)
TRACE("ft6x36: thrhld = %d", TS_IO_Read(TOUCH_FT6236_REG_TH_GROUP) * 4);
TRACE("ft6x36: rep rate=", TS_IO_Read(TOUCH_FT6236_REG_PERIODACTIVE) * 10);
TRACE("ft6x36: fw lib 0x%02X %02X", TS_IO_Read(TOUCH_FT6236_REG_LIB_VER_H), TS_IO_Read(TOUCH_FT6236_REG_LIB_VER_L));
TRACE("ft6x36: fw v 0x%02X", TS_IO_Read(TOUCH_FT6236_REG_FIRMID));
TRACE("ft6x36: CHIP ID 0x%02X", TS_IO_Read(TOUCH_FT6236_REG_CIPHER));
TRACE("ft6x36: CTPM ID 0x%02X", TS_IO_Read(TOUCH_FT6236_REG_FOCALTECH_ID));
TRACE("ft6x36: rel code 0x%02X", TS_IO_Read(TOUCH_FT6236_REG_RELEASE_CODE_ID));
#endif
}
/**
* @brief Return if there is touches detected or not.
* Try to detect new touches and forget the old ones (reset internal global
* variables).
* @param DeviceAddr: Device address on communication Bus.
* @retval : Number of active touches detected (can be 0, 1 or 2).
*/
static uint8_t ft6x06_TS_DetectTouch(uint16_t DeviceAddr)
{
volatile uint8_t nbTouch = 0;
/* Read register FT6206_TD_STAT_REG to check number of touches detection */
nbTouch = TS_IO_Read(DeviceAddr, FT6206_TD_STAT_REG);
nbTouch &= FT6206_TD_STAT_MASK;
if(nbTouch > FT6206_MAX_DETECTABLE_TOUCH)
{
/* If invalid number of touch detected, set it to zero */
nbTouch = 0;
}
/* Update ft6x06 driver internal global : current number of active touches */
ft6x06_handle.currActiveTouchNb = nbTouch;
/* Reset current active touch index on which to work on */
ft6x06_handle.currActiveTouchIdx = 0;
return(nbTouch);
}
/**
* @brief Get the touch detailed informations on touch number 'touchIdx' (0..1)
* This touch detailed information contains :
* - weight that was applied to this touch
* - sub-area of the touch in the touch panel
* - event of linked to the touch (press down, lift up, ...)
* @param DeviceAddr: Device address on communication Bus (I2C slave address of FT6x06).
* @param touchIdx : Passed index of the touch (0..1) on which we want to get the
* detailed information.
* @param pWeight : Pointer to to get the weight information of 'touchIdx'.
* @param pArea : Pointer to to get the sub-area information of 'touchIdx'.
* @param pEvent : Pointer to to get the event information of 'touchIdx'.
* @retval None.
*/
static void ft6x06_TS_GetTouchInfo(uint16_t DeviceAddr,
uint32_t touchIdx,
uint32_t * pWeight,
uint32_t * pArea,
uint32_t * pEvent)
{
uint8_t regAddress = 0;
uint8_t dataxy[3];
if(touchIdx < ft6x06_handle.currActiveTouchNb)
{
switch(touchIdx)
{
case 0 :
regAddress = FT6206_P1_WEIGHT_REG;
break;
case 1 :
regAddress = FT6206_P2_WEIGHT_REG;
break;
default :
break;
} /* end switch(touchIdx) */
/* Read weight, area and Event Id of touch index */
TS_IO_ReadMultiple(DeviceAddr, regAddress, dataxy, sizeof(dataxy));
/* Return weight of touch index */
* pWeight = (dataxy[0] & FT6206_TOUCH_WEIGHT_MASK) >> FT6206_TOUCH_WEIGHT_SHIFT;
/* Return area of touch index */
* pArea = (dataxy[1] & FT6206_TOUCH_AREA_MASK) >> FT6206_TOUCH_AREA_SHIFT;
/* Return Event Id of touch index */
* pEvent = (dataxy[2] & FT6206_TOUCH_EVT_FLAG_MASK) >> FT6206_TOUCH_EVT_FLAG_SHIFT;
} /* of if(touchIdx < ft6x06_handle.currActiveTouchNb) */
}
/**
* @brief Get the touch screen X and Y positions values
* Manage multi touch thanks to touch Index global
* variable 'ft6x06_handle.currActiveTouchIdx'.
* @param DeviceAddr: Device address on communication Bus.
* @param X: Pointer to X position value
* @param Y: Pointer to Y position value
* @retval None.
*/
static void ft6x06_TS_GetXY(uint16_t DeviceAddr, uint16_t *X, uint16_t *Y, uint32_t *event)
{
uint8_t regAddress = 0;
uint8_t dataxy[4];
if(ft6x06_handle.currActiveTouchIdx < ft6x06_handle.currActiveTouchNb)
{
switch(ft6x06_handle.currActiveTouchIdx)
{
case 0 :
regAddress = FT6206_P1_XH_REG;
break;
case 1 :
regAddress = FT6206_P2_XH_REG;
break;
default :
break;
}
/* Read X and Y positions */
TS_IO_ReadMultiple(DeviceAddr, regAddress, dataxy, sizeof(dataxy));
/* Send back ready X position to caller */
*X = ((dataxy[0] & FT6206_MSB_MASK) << 8) | (dataxy[1] & FT6206_LSB_MASK);
/* Send back ready Y position to caller */
*Y = ((dataxy[2] & FT6206_MSB_MASK) << 8) | (dataxy[3] & FT6206_LSB_MASK);
*event = (dataxy[0] & FT6206_TOUCH_EVT_FLAG_MASK) >> FT6206_TOUCH_EVT_FLAG_SHIFT;
/*
uint32_t weight;
uint32_t area;
ft6x06_TS_GetTouchInfo(DeviceAddr, ft6x06_handle.currActiveTouchIdx, &weight, &area, event);
*/
ft6x06_handle.currActiveTouchIdx++;
}
}
static void ft6x06_TS_GetGestureID(uint16_t DeviceAddr, uint32_t * pGestureId)
{
*pGestureId = TS_IO_Read(DeviceAddr, FT6206_GEST_ID_REG);
}
void TouchReset(){
GPIO_ResetBits(I2C_TOUCH_RESET_GPIO, I2C_TOUCH_RESET_GPIO_PIN);
delay_ms(20);
GPIO_SetBits(I2C_TOUCH_RESET_GPIO, I2C_TOUCH_RESET_GPIO_PIN);
delay_ms(300);
}
void TouchInit( void )
{
I2C_Init();
TouchReset();
touch_ft6236_debug_info();
/* INT generation for new touch available */
/* Note TS_INT is active low */
uint8_t regValue = 0;
regValue = (FT6206_G_MODE_INTERRUPT_TRIGGER & (FT6206_G_MODE_INTERRUPT_MASK >> FT6206_G_MODE_INTERRUPT_SHIFT)) << FT6206_G_MODE_INTERRUPT_SHIFT;
/* Set interrupt TOUCH_FT6236_I2C_ADDRESS mode in FT6206_GMODE_REG */
TS_IO_Write(TOUCH_FT6236_I2C_ADDRESS, FT6206_GMODE_REG, regValue);
//enter standard mode
//TS_IO_Write(TOUCH_FT6236_I2C_ADDRESS, 0,0);
/*trigger reset */
TouchReset();
//Try to enable gesture
/*
TS_IO_Write(TOUCH_FT6236_I2C_ADDRESS, FT6206_GMODE_REG, regValue);
TS_IO_Write(TOUCH_FT6236_I2C_ADDRESS, 0xD1, 0xff);
TS_IO_Write(TOUCH_FT6236_I2C_ADDRESS, 0xD2, 0xff);
TS_IO_Write(TOUCH_FT6236_I2C_ADDRESS, 0xD5, 0xff);
TS_IO_Write(TOUCH_FT6236_I2C_ADDRESS, 0xD6, 0xff);
TS_IO_Write(TOUCH_FT6236_I2C_ADDRESS, 0xD7, 0xff);
TS_IO_Write(TOUCH_FT6236_I2C_ADDRESS, 0xD8, 0xff);
TS_IO_Write(TOUCH_FT6236_I2C_ADDRESS, 0xD0, 1);
*/
}
void handleTouch()
{
ft6x06_TS_GetXY(TOUCH_FT6236_I2C_ADDRESS, &Tx, &Ty, &TouchEvent);
uint32_t gesture;
ft6x06_TS_GetGestureID(TOUCH_FT6236_I2C_ADDRESS, &gesture);
#if defined( LCD_DIRECTION ) && ( LCD_DIRECTION == LCD_VERTICAL )
Tx=LCD_WIDTH-Tx;
Ty=LCD_HEIGHT-Ty;
#else
x = ( LCD_WIDTH - 1 ) - Ty;
Ty = Tx;
Tx = x;
#endif
if( 2 == TouchEvent )
{
TouchCycle = 0;
if( ReadTouchData( TouchBuffer, sizeof( TouchBuffer ) ) )
touchState.X = Tx;
touchState.Y = Ty;
if( TOUCH_NONE == TouchState )
{
TouchEvent = TouchBuffer[3] >> 6;
Tx = TouchBuffer[3] & 0x0f;
Tx <<= 8;
Tx |= TouchBuffer[4];
Ty = TouchBuffer[5] & 0x0f;
Ty <<= 8;
Ty |= TouchBuffer[6];
touchState.Event = TE_NONE;
TouchState = TOUCH_CLICK;
#if defined( LCD_DIRECTION ) && ( LCD_DIRECTION == LCD_VERTICAL )
Tx=LCD_WIDTH-Tx;
Ty=LCD_HEIGHT-Ty;
#else
x = ( LCD_WIDTH - 1 ) - Ty;
Ty = Tx;
Tx = x;
#endif
if( 2 == TouchEvent )
TouchStartX = Tx;
TouchStartY = Ty;
if (g_eeGeneral.backlightMode & e_backlight_mode_keys)
backlightOn(); // TODO is that the best place ?
}
else
{
if ( TOUCH_CLICK == TouchState )
{
touchState.X = Tx;
touchState.Y = Ty;
x = Tx - Txold;
y = Ty - Tyold;
if( TOUCH_NONE == TouchState )
{
touchState.Event = TE_NONE;
TouchState = TOUCH_CLICK;
TouchStartX = Tx;
TouchStartY = Ty;
if (g_eeGeneral.backlightMode & e_backlight_mode_keys)
backlightOn(); // TODO is that the best place ?
}
else
{
if ( TOUCH_CLICK == TouchState )
{
x = Tx - Txold;
y = Ty - Tyold;
if( ( x >= SLIDE_RANGE ) || ( x <= -SLIDE_RANGE ) || ( y >= SLIDE_RANGE ) || ( y <= -SLIDE_RANGE ) )
{
TouchState = TOUCH_SLIDE;
touchState.Event = TE_SLIDE;
}
else
{
touchState.Event = TE_DOWN;
touchState.startX = touchState.lastX = touchState.X;
touchState.startY = touchState.lastY = touchState.Y;
}
}
else if ( TOUCH_SLIDE == TouchState )
{
touchState.Event = TE_SLIDE;
}
else
{
TouchState = TOUCH_NONE;
}
}
Txold = Tx;
Tyold = Ty;
if( ( x >= SLIDE_RANGE ) || ( x <= -SLIDE_RANGE ) || ( y >= SLIDE_RANGE ) || ( y <= -SLIDE_RANGE ) )
{
TouchState = TOUCH_SLIDE;
touchState.Event = TE_SLIDE;
}
else
{
touchState.Event = TE_DOWN;
touchState.startX = touchState.lastX = touchState.X;
touchState.startY = touchState.lastY = touchState.Y;
}
}
else if ( TOUCH_SLIDE == TouchState )
{
touchState.Event = TE_SLIDE;
}
else
{
if ( TOUCH_CLICK == TouchState )
{
touchState.X = Txold;
touchState.Y = Tyold;
touchState.Event = TE_UP;
touchState.Time = get_tmr10ms();
}
else if (get_tmr10ms() > touchState.Time + 50)
{
touchState.X = LCD_WIDTH;
touchState.Y = LCD_HEIGHT;
touchState.Event = TE_NONE;
}
TouchState = TOUCH_NONE;
}
}
else
Txold = Tx;
Tyold = Ty;
}
}
extern "C" void EXTI9_5_IRQHandler(void) {
if(EXTI_GetITStatus(EXTI_Line9) != RESET) {
if(ft6x06_TS_DetectTouch(TOUCH_FT6236_I2C_ADDRESS)){
handleTouch();
/*
TRACE("X %d Y %d", x, y);
uint32_t gesture;
ft6x06_TS_GetGestureID(TOUCH_FT6236_I2C_ADDRESS, &gesture);
if(gesture != TOUCH_FT6236_GESTURE_NONE) TRACE("gesture %d", gesture);
TS_IO_Read(TOUCH_FT6236_I2C_ADDRESS, 0xD3);
if(gesture != TOUCH_FT6236_GESTURE_NONE) TRACE("gesture d3 %d", gesture);
*/
}
else
{
if ( TOUCH_CLICK == TouchState )
{
touchState.X = Txold;
touchState.Y = Tyold;
touchState.Event = TE_UP;
touchState.Time = get_tmr10ms();
}
else if (get_tmr10ms() > touchState.Time + 50)
{
touchState.X = LCD_WIDTH;
touchState.Y = LCD_HEIGHT;
touchState.Event = TE_NONE;
TouchState = TOUCH_NONE;
}
TouchState = TOUCH_NONE;
}
EXTI_ClearITPendingBit(EXTI_Line9);
}
}
radio/src/targets/nv14/touch_driver.h
+295 -46
View File
@@ -17,41 +17,306 @@
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#ifndef __TOUCH_DRIVER_H__
#define __TOUCH_DRIVER_H__
/*
Copyright 2016 fishpepper <AT> gmail.com
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 3 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, see <http://www.gnu.org/licenses/>.
author: fishpepper <AT> gmail.com
*/
/**
******************************************************************************
* @file ft6x06.h
* @author MCD Application Team
* @version V1.0.0
* @date 03-August-2015
* @brief This file contains all the functions prototypes for the
* ft6x06.c IO expander driver.
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. Neither the name of STMicroelectronics nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************
*/
#ifndef __FT6X06_H
#define __FT6X06_H
#include "board.h"
#include "touch.h"
#ifdef __cplusplus
extern "C" {
#endif
#define PORT_TOUCH_SCL ( GPIOB )
#define PIN_TOUCH_SCL ( GPIO_Pin_8 )
#define PORT_TOUCH_SDA ( GPIOB )
#define PIN_TOUCH_SDA ( GPIO_Pin_7 )
#define PORT_TOUCH_RESET ( GPIOB )
#define PIN_TOUCH_RESET ( GPIO_Pin_12 )
#include <stdint.h>
#define PORT_TOUCH_INT ( GPIOB )
#define PIN_TOUCH_INT ( GPIO_Pin_9 )
/* Set Multi-touch as non supported */
#ifndef TS_MULTI_TOUCH_SUPPORTED
#define TS_MULTI_TOUCH_SUPPORTED 0
#endif
#define SET_TOUCH_INT_IN() GPIO_SetDirection( PORT_TOUCH_INT, 9, 1 )
/* Set Auto-calibration as non supported */
#ifndef TS_AUTO_CALIBRATION_SUPPORTED
#define TS_AUTO_CALIBRATION_SUPPORTED 0
#endif
#define SET_TOUCH_RESET_OUT() GPIO_SetDirection( PORT_TOUCH_RESET, 12, 0 )
#define SET_TOUCH_RESET() GPIO_WriteBit( PORT_TOUCH_RESET,PIN_TOUCH_RESET, Bit_SET )
#define CLR_TOUCH_RESET() GPIO_WriteBit( PORT_TOUCH_RESET,PIN_TOUCH_RESET, Bit_RESET )
/* Macros --------------------------------------------------------------------*/
#define SET_TOUCH_SCL_OUT() GPIO_SetDirection( PORT_TOUCH_SCL, 8, 0 )
#define SET_TOUCH_SCL() GPIO_WriteBit( PORT_TOUCH_SCL,PIN_TOUCH_SCL, Bit_SET )
#define CLR_TOUCH_SCL() GPIO_WriteBit( PORT_TOUCH_SCL,PIN_TOUCH_SCL, Bit_RESET )
/** @typedef ft6x06_handle_TypeDef
* ft6x06 Handle definition.
*/
typedef struct
{
uint8_t i2cInitialized;
#define SET_TOUCH_SDA_IN() GPIO_SetDirection( PORT_TOUCH_SDA, 7, 1 )
#define SET_TOUCH_SDA_OUT() GPIO_SetDirection( PORT_TOUCH_SDA, 7, 0 )
/* field holding the current number of simultaneous active touches */
uint8_t currActiveTouchNb;
#define SET_TOUCH_SDA() GPIO_WriteBit(PORT_TOUCH_SDA, PIN_TOUCH_SDA, Bit_SET)
#define CLR_TOUCH_SDA() GPIO_WriteBit(PORT_TOUCH_SDA, PIN_TOUCH_SDA, Bit_RESET)
/* field holding the touch index currently managed */
uint8_t currActiveTouchIdx;
#define READ_TOUCH_SDA() GPIO_ReadInputDataBit( PORT_TOUCH_SDA, PIN_TOUCH_SDA )
} ft6x06_handle_TypeDef;
#define TOUCH_FT6236_MAX_TOUCH_POINTS 2
#define TOUCH_FT6236_REG_TH_GROUP 0x80
#define TOUCH_FT6236_REG_PERIODACTIVE 0x88
#define TOUCH_FT6236_REG_LIB_VER_H 0xa1
#define TOUCH_FT6236_REG_LIB_VER_L 0xa2
#define TOUCH_FT6236_REG_CIPHER 0xa3
#define TOUCH_FT6236_REG_FIRMID 0xa6
#define TOUCH_FT6236_REG_FOCALTECH_ID 0xa8
#define TOUCH_FT6236_REG_RELEASE_CODE_ID 0xaf
#define TOUCH_FT6236_EVENT_PRESS_DOWN 0
#define TOUCH_FT6236_EVENT_LIFT_UP 1
#define TOUCH_FT6236_EVENT_CONTACT 2
#define TOUCH_FT6236_EVENT_NO_EVENT 3
#define TOUCH_FT6236_GESTURE_MOVE_FLAG 0x10
#define TOUCH_FT6236_GESTURE_MOVE_UP 0x10
#define TOUCH_FT6236_GESTURE_MOVE_RIGHT 0x14
#define TOUCH_FT6236_GESTURE_MOVE_DOWN 0x18
#define TOUCH_FT6236_GESTURE_MOVE_LEFT 0x1C
#define TOUCH_FT6236_GESTURE_ZOOM_IN 0x48
#define TOUCH_FT6236_GESTURE_ZOOM_OUT 0x49
#define TOUCH_FT6236_GESTURE_NONE 0x00
#define TOUCH_GESTURE_UP ((TOUCH_FT6236_GESTURE_MOVE_UP & 0x0F)+1)
#define TOUCH_GESTURE_DOWN ((TOUCH_FT6236_GESTURE_MOVE_DOWN & 0x0F)+1)
#define TOUCH_GESTURE_LEFT ((TOUCH_FT6236_GESTURE_MOVE_LEFT & 0x0F)+1)
#define TOUCH_GESTURE_RIGHT ((TOUCH_FT6236_GESTURE_MOVE_RIGHT & 0x0F)+1)
#define TOUCH_GESTURE_MOUSE_DOWN (0x80+TOUCH_FT6236_EVENT_PRESS_DOWN)
#define TOUCH_GESTURE_MOUSE_UP (0x80+TOUCH_FT6236_EVENT_LIFT_UP)
#define TOUCH_GESTURE_MOUSE_MOVE (0x80+TOUCH_FT6236_EVENT_CONTACT)
#define TOUCH_GESTURE_MOUSE_NONE (0x80+TOUCH_FT6236_EVENT_NO_EVENT)
/* Maximum border values of the touchscreen pad */
#define FT_6206_MAX_WIDTH ((uint16_t)800) /* Touchscreen pad max width */
#define FT_6206_MAX_HEIGHT ((uint16_t)480) /* Touchscreen pad max height */
/* Possible values of driver functions return status */
#define FT6206_STATUS_OK 0
#define FT6206_STATUS_NOT_OK 1
/* Possible values of global variable 'TS_I2C_Initialized' */
#define FT6206_I2C_NOT_INITIALIZED 0
#define FT6206_I2C_INITIALIZED 1
/* Max detectable simultaneous touches */
#define FT6206_MAX_DETECTABLE_TOUCH 2
/**
* @brief : Definitions for FT6206 I2C register addresses on 8 bit
**/
/* Current mode register of the FT6206 (R/W) */
#define FT6206_DEV_MODE_REG 0x00
/* Possible values of FT6206_DEV_MODE_REG */
#define FT6206_DEV_MODE_WORKING 0x00
#define FT6206_DEV_MODE_FACTORY 0x04
#define FT6206_DEV_MODE_MASK 0x7
#define FT6206_DEV_MODE_SHIFT 4
/* Gesture ID register */
#define FT6206_GEST_ID_REG 0x01
/* Possible values of FT6206_GEST_ID_REG */
#define FT6206_GEST_ID_NO_GESTURE 0x00
#define FT6206_GEST_ID_MOVE_UP 0x10
#define FT6206_GEST_ID_MOVE_RIGHT 0x14
#define FT6206_GEST_ID_MOVE_DOWN 0x18
#define FT6206_GEST_ID_MOVE_LEFT 0x1C
#define FT6206_GEST_ID_ZOOM_IN 0x48
#define FT6206_GEST_ID_ZOOM_OUT 0x49
/* Touch Data Status register : gives number of active touch points (0..2) */
#define FT6206_TD_STAT_REG 0x02
/* Values related to FT6206_TD_STAT_REG */
#define FT6206_TD_STAT_MASK 0x0F
#define FT6206_TD_STAT_SHIFT 0x00
/* Values Pn_XH and Pn_YH related */
#define FT6206_TOUCH_EVT_FLAG_PRESS_DOWN 0x00
#define FT6206_TOUCH_EVT_FLAG_LIFT_UP 0x01
#define FT6206_TOUCH_EVT_FLAG_CONTACT 0x02
#define FT6206_TOUCH_EVT_FLAG_NO_EVENT 0x03
#define FT6206_TOUCH_EVT_FLAG_SHIFT 6
#define FT6206_TOUCH_EVT_FLAG_MASK (3 << FT6206_TOUCH_EVT_FLAG_SHIFT)
#define FT6206_MSB_MASK 0x0F
#define FT6206_MSB_SHIFT 0
/* Values Pn_XL and Pn_YL related */
#define FT6206_LSB_MASK 0xFF
#define FT6206_LSB_SHIFT 0
#define FT6206_P1_XH_REG 0x03
#define FT6206_P1_XL_REG 0x04
#define FT6206_P1_YH_REG 0x05
#define FT6206_P1_YL_REG 0x06
/* Touch Pressure register value (R) */
#define FT6206_P1_WEIGHT_REG 0x07
/* Values Pn_WEIGHT related */
#define FT6206_TOUCH_WEIGHT_MASK 0xFF
#define FT6206_TOUCH_WEIGHT_SHIFT 0
/* Touch area register */
#define FT6206_P1_MISC_REG 0x08
/* Values related to FT6206_Pn_MISC_REG */
#define FT6206_TOUCH_AREA_MASK (0x04 << 4)
#define FT6206_TOUCH_AREA_SHIFT 0x04
#define FT6206_P2_XH_REG 0x09
#define FT6206_P2_XL_REG 0x0A
#define FT6206_P2_YH_REG 0x0B
#define FT6206_P2_YL_REG 0x0C
#define FT6206_P2_WEIGHT_REG 0x0D
#define FT6206_P2_MISC_REG 0x0E
/* Threshold for touch detection */
#define FT6206_TH_GROUP_REG 0x80
/* Values FT6206_TH_GROUP_REG : threshold related */
#define FT6206_THRESHOLD_MASK 0xFF
#define FT6206_THRESHOLD_SHIFT 0
/* Filter function coefficients */
#define FT6206_TH_DIFF_REG 0x85
/* Control register */
#define FT6206_CTRL_REG 0x86
/* Values related to FT6206_CTRL_REG */
/* Will keep the Active mode when there is no touching */
#define FT6206_CTRL_KEEP_ACTIVE_MODE 0x00
/* Switching from Active mode to Monitor mode automatically when there is no touching */
#define FT6206_CTRL_KEEP_AUTO_SWITCH_MONITOR_MODE 0x01
/* The time period of switching from Active mode to Monitor mode when there is no touching */
#define FT6206_TIMEENTERMONITOR_REG 0x87
/* Report rate in Active mode */
#define FT6206_PERIODACTIVE_REG 0x88
/* Report rate in Monitor mode */
#define FT6206_PERIODMONITOR_REG 0x89
/* The value of the minimum allowed angle while Rotating gesture mode */
#define FT6206_RADIAN_VALUE_REG 0x91
/* Maximum offset while Moving Left and Moving Right gesture */
#define FT6206_OFFSET_LEFT_RIGHT_REG 0x92
/* Maximum offset while Moving Up and Moving Down gesture */
#define FT6206_OFFSET_UP_DOWN_REG 0x93
/* Minimum distance while Moving Left and Moving Right gesture */
#define FT6206_DISTANCE_LEFT_RIGHT_REG 0x94
/* Minimum distance while Moving Up and Moving Down gesture */
#define FT6206_DISTANCE_UP_DOWN_REG 0x95
/* Maximum distance while Zoom In and Zoom Out gesture */
#define FT6206_DISTANCE_ZOOM_REG 0x96
/* High 8-bit of LIB Version info */
#define FT6206_LIB_VER_H_REG 0xA1
/* Low 8-bit of LIB Version info */
#define FT6206_LIB_VER_L_REG 0xA2
/* Chip Selecting */
#define FT6206_CIPHER_REG 0xA3
/* Interrupt mode register (used when in interrupt mode) */
#define FT6206_GMODE_REG 0xA4
#define FT6206_G_MODE_INTERRUPT_MASK 0x03
#define FT6206_G_MODE_INTERRUPT_SHIFT 0x00
/* Possible values of FT6206_GMODE_REG */
#define FT6206_G_MODE_INTERRUPT_POLLING 0x00
#define FT6206_G_MODE_INTERRUPT_TRIGGER 0x01
/* Current power mode the FT6206 system is in (R) */
#define FT6206_PWR_MODE_REG 0xA5
/* FT6206 firmware version */
#define FT6206_FIRMID_REG 0xA6
/* FT6206 Chip identification register */
#define FT6206_CHIP_ID_REG 0xA8
/* Possible values of FT6206_CHIP_ID_REG */
#define FT6206_ID_VALUE 0x11
/* Release code version */
#define FT6206_RELEASE_CODE_ID_REG 0xAF
/* Current operating mode the FT6206 system is in (R) */
#define FT6206_STATE_REG 0xBC
#define TOUCH_PANEL_ADDRESS ( 0x38 )
#define LCD_VERTICAL ( 0x00 )
#define LCD_HORIZONTAL ( 0x01 )
@@ -60,27 +325,11 @@
#define LCD_WIDTH ( 320 )
#define LCD_HEIGHT ( 480 )
#define TOUCH_INVALID ( 250 )
enum ENUM_IO_SPEED
{
IO_SPEED_LOW,
IO_SPEED_MID,
IO_SPEED_QUICK,
IO_SPEED_HIGH
};
enum ENUM_IO_MODE
{
IO_MODE_INPUT,
IO_MODE_OUTPUT,
IO_MODE_ALTERNATE,
IO_MODE_ANALOG
};
#define GET_ARRAY_SIZE( ARRAY ) ( ( sizeof( ARRAY ) ) / ( sizeof( ARRAY[0] ) ) )
extern void TouchInit( void );
extern void TouchDriver( void );
#endif /*__TOUCH_DRIVER_H__*/
#ifdef __cplusplus
}
#endif
#endif /* __FT6X06_H */