Stmpe811qtr C

H:\y4_LCD_TFT\0_utility\STemWin\ProgettoLCDProvaWork\Project\STMPE811QTR.
venerd 16 gennaio 2015 15:50
/**
******************************************************************************
* <h2><center>© COPYRIGHT 2012 Embest Tech. Co., Ltd.</center></h2>
* @file
STMPE811QTR.c
* @author CMP Team
* @version V1.0.0
* @date
28-December-2012
* @brief
LCD touch screen controler driver
******************************************************************************
* @attention
*
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
* TIME. AS A RESULT, Embest SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT
* OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
* OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
* CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "stmpe811qtr.h"
/** @defgroup STM32F4xx_StdPeriph_Examples
* @{
*/
#define TIMEOUT_MAX
0x3000 /*<! The value of the maximal timeout for I2C waiting loops */
/**
* @}
*/
/** @defgroup STM32F4_DISCOVERY_IOE_Private_Variables

* @{
*/
TS_STATE TS_State;
/*<! The global structure holding the TS state */
uint32_t IOE_TimeOut = TIMEOUT_MAX; /*<! Value of Timeout when I2C communication fails */
/**
* @}
*/
/** @defgroup STM32F4_DISCOVERY_IOE_Private_FunctionPrototypes

* @{
*/
static uint16_t IOE_TS_Read_Z(void);
static
static
static
static
void
void
void
void
IOE_GPIO_Config(void);
IOE_I2C_Config(void);
IOE_DMA_Config(IOE_DMADirection_TypeDef Direction, uint8_t* buffer);
IOE_EXTI_Config(void);
#ifndef USE_Delay
static void delay(__IO uint32_t nCount);
#endif /* USE_Delay*/
/**
-1-
H:\y4_LCD_TFT\0_utility\STemWin\ProgettoLCDProvaWork\Project\STMPE811QTR.c
* @}
*/
/** @defgroup STM32F4_DISCOVERY_IOE_Private_Functions

* @{
*/
/**
* @brief Initializes and Configures the two IO_Expanders Functionalities
*
(IOs, Touch Screen ..) and configures all STM32F4_DISCOVERY necessary
*
hardware (GPIOs, APB clocks ..).
* @param None
* @retval IOE_OK if all initializations done correctly. Other value if error.
*/
uint8_t IOE_Config(void)
{
/* Configure the needed pins */
IOE_GPIO_Config();
IOE_I2C_Config();
/* Read IO Expander 1 ID */
if (IOE_IsOperational(IOE_1_ADDR)) {
return IOE1_NOT_OPERATIONAL;
}
/* Generate IOExpander Software reset */
IOE_Reset(IOE_1_ADDR);
/* ---------------------- IO Expander 1 configuration --------------------- */
/* Enable the GPIO, Touch Screen and ADC functionalities */
IOE_FnctCmd(IOE_1_ADDR, IOE_IO_FCT | IOE_TS_FCT | IOE_ADC_FCT, ENABLE);
/* Touch Screen controller configuration */
IOE_TS_Config();
/* Configuration is OK */
return IOE_OK;
}
/**
* @brief Configures The selected interrupts on the IO Expanders.
* @param IOE_ITSRC_Source: the source of the interrupts. Could be one or a
*
combination of the following parameters:
*
@arg IOE_ITSRC_JOYSTICK: Joystick IO intputs.
*
@arg IOE_ITSRC_TSC: Touch Screen interrupts.
*
@arg IOE_ITSRC_INMEMS: MEMS interrupt lines.
* @retval IOE_OK: if all initializations are OK. Other value if error.
*/
uint8_t IOE_ITConfig(uint32_t IOE_ITSRC_Source)
{
/* Configure the Interrupt output pin to generate low level (INT_CTRL) */
IOE_ITOutConfig(Polarity_High, Type_Level);
/* Manage the Touch Screen Interrupts */
-2-
if (IOE_ITSRC_Source & IOE_ITSRC_TSC) {

/* Enable the Global interrupt */
IOE_GITCmd(IOE_1_ADDR, ENABLE);
/* Enable the Global GPIO Interrupt */
IOE_GITConfig(IOE_1_ADDR, (uint8_t)(IOE_GIT_TOUCH | IOE_GIT_FTH), ENABLE);
/* Read the GPIO_IT_STA to clear all pending bits if any */
I2C_ReadDeviceRegister(IOE_1_ADDR, IOE_REG_GPIO_INT_STA);
}
/* Configure the Interrupt line as EXTI source */
IOE_EXTI_Config();
/* If all OK return IOE_OK */
return IOE_OK;
}
/**
* @brief Returns Status and positions of the Touch screen.
* @param None
* @retval Pointer to TS_STATE structure holding Touch Screen information.
*/
TS_STATE* IOE_TS_GetState(void)
{
uint16_t xDiff, yDiff , x , y;
static uint16_t _x = 0, _y = 0;
/* Check if the Touch detect event happened */
TS_State.TouchDetected = (I2C_ReadDeviceRegister(IOE_1_ADDR, IOE_REG_TSC_CTRL) & 0x80);
if (TS_State.TouchDetected) {
x = IOE_TS_Read_X();
y = IOE_TS_Read_Y();
xDiff = x > _x? (x - _x): (_x - x);
yDiff = y > _y? (y - _y): (_y - y);
if (xDiff + yDiff > 5) {
_x = x;
_y = y;
}
}
/* Update the X position */
TS_State.X = _x;
/* Update the Y position */
TS_State.Y = _y;
/* Update the Z position index */
TS_State.Z = IOE_TS_Read_Z();
/* Clear the interrupt pending bit and enable the FIFO again */
I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_FIFO_STA, 0x01);
/* Return pointer to the updated structure */
return &TS_State;
}
-3-
/**
* @brief Checks the selected Global interrupt source pending bit
* @param DeviceAddr: The address of the IOExpander, could be : IOE_1_ADDR
*
or IOE_2_ADDR.
* @param Global_IT: the Global interrupt source to be checked, could be:
*
@arg Global_IT_GPIO : All IOs interrupt
*
@arg Global_IT_ADC : ADC interrupt
*
@arg Global_IT_TEMP : Temperature Sensor interrupts
*
@arg Global_IT_FE : Touch Screen Controller FIFO Error interrupt
*
@arg Global_IT_FF : Touch Screen Controller FIFO Full interrupt
*
@arg Global_IT_FOV : Touch Screen Controller FIFO Overrun interrupt
*
@arg Global_IT_FTH : Touch Screen Controller FIFO Threshold interrupt
*
@arg Global_IT_TOUCH : Touch Screen Controller Touch Detected interrupt
* @retval Status of the checked flag. Could be SET or RESET.
*/
FlagStatus IOE_GetGITStatus(uint8_t DeviceAddr, uint8_t Global_IT)
{
__IO uint8_t tmp = 0;
/* get the Interrupt status */
tmp = I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_INT_STA);
if ((tmp & (uint8_t)Global_IT) != 0) {
return SET;
} else {
return RESET;
}
}
/**
* @brief Clears the selected Global interrupt pending bit(s)
*
or IOE_2_ADDR.
* @param Global_IT: the Global interrupt to be cleared, could be any combination
*
of the following values:
*
*
*
*
*
*
*
*
*/
uint8_t IOE_ClearGITPending(uint8_t DeviceAddr, uint8_t Global_IT)
{
/* Write 1 to the bits that have to be cleared */
I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_INT_STA, Global_IT);
return IOE_OK;
}
/**
* @brief
* @param
Checks the status of the selected IO interrupt pending bit

DeviceAddr: The address of the IOExpander, could be : IOE_1_ADDR
-4-
*
or IOE_2_ADDR.
* @param IO_IT: the IO interrupt to be checked could be IO_ITx Where x can be
*
from 0 to 7.
* @retval Status of the checked flag. Could be SET or RESET.
*/
FlagStatus IOE_GetIOITStatus(uint8_t DeviceAddr, uint8_t IO_IT)
{
uint8_t tmp = 0;
/* get the Interrupt status */
tmp = I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_GPIO_INT_STA);
if ((tmp & (uint8_t)IO_IT) != 0) {
return SET;
} else {
return RESET;
}
}
/**
* @brief Checks if the selected device is correctly configured and
*
communicates correctly on the I2C bus.
*
or IOE_2_ADDR.
* @retval IOE_OK if IOE is operational. Other value if failure.
*/
uint8_t IOE_IsOperational(uint8_t DeviceAddr)
{
/* Return Error if the ID is not correct */
if ( IOE_ReadID(DeviceAddr) != (uint16_t)STMPE811_ID ) {
/* Check if a Timeout occurred */
if (IOE_TimeOut == 0) {
return(IOE_TimeoutUserCallback());
} else {
return IOE_FAILURE; /* ID is not Correct */
}
} else {
return IOE_OK; /* ID is correct */
}
}
/**
* @brief Resets the IO Expander by Software (SYS_CTRL1, RESET bit).
*
or IOE_2_ADDR.
*/
uint8_t IOE_Reset(uint8_t DeviceAddr)
{
/* Power Down the IO_Expander */
I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_SYS_CTRL1, 0x02);
/* wait for a delay to insure registers erasing */
_delay_(2);
/* Power On the Codec after the power off => all registers are reinitialized*/
I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_SYS_CTRL1, 0x00);
-5-

return IOE_OK;
}
/**
* @brief Reads the selected device's ID.
*
or IOE_2_ADDR.
* @retval The Device ID (two bytes).
*/
uint16_t IOE_ReadID(uint8_t DeviceAddr)
{
uint16_t tmp = 0;
/* Read device ID */
tmp = I2C_ReadDeviceRegister(DeviceAddr, 0);
tmp = (uint32_t)(tmp << 8);
tmp |= (uint32_t)I2C_ReadDeviceRegister(DeviceAddr, 1);
/* Return the ID */
return (uint16_t)tmp;
}
/**
* @brief Configures the selected IO Expander functionalities.
*
or IOE_2_ADDR.
* @param IOE_TEMPSENS_FCT: the functions to be configured. could be any
*
combination of the following values:
*
@arg IOE_IO_FCT : IO function
*
@arg IOE_TS_FCT : Touch Screen function
*
@arg IOE_ADC_FCT : ADC function
*
@arg IOE_TEMPSENS_FCT : Temperature Sensor function
*/
uint8_t IOE_FnctCmd(uint8_t DeviceAddr, uint8_t Fct, FunctionalState NewState)
{
uint8_t tmp = 0;
/* Get the register value */
tmp = I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_SYS_CTRL2);
if (NewState != DISABLE) {
/* Set the Functionalities to be Enabled */
tmp &= ~(uint8_t)Fct;
} else {
/* Set the Functionalities to be Disabled */
tmp |= (uint8_t)Fct;
}
/* Set the register value */
I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_SYS_CTRL2, tmp);
return IOE_OK;
}
-6-
/**
* @brief Configures the selected pin direction (to be an input or an output)
*
or IOE_2_ADDR.
* @param IO_Pin: IO_Pin_x: Where x can be from 0 to 7.
* @param Direction: could be Direction_IN or Direction_OUT.
*/
uint8_t IOE_IOPinConfig(uint8_t DeviceAddr, uint8_t IO_Pin, uint8_t Direction)
{
uint8_t tmp = 0;
/* Get all the Pins direction */
tmp = I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_GPIO_DIR);
if (Direction != Direction_IN) {
tmp |= (uint8_t)IO_Pin;
} else {
tmp &= ~(uint8_t)IO_Pin;
}
/* Write the register new value */
I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_GPIO_DIR, tmp);
return IOE_OK;
}
/**
* @brief Enables or disables the Global interrupt.
* @param DeviceAddr: The address of the IOExpander, could be :I OE_1_ADDR
*
or IOE_2_ADDR.
* @param NewState: could be ENABLE or DISABLE.
*/
uint8_t IOE_GITCmd(uint8_t DeviceAddr, FunctionalState NewState)
{
uint8_t tmp = 0;
/* Read the Interrupt Control register */
I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_INT_CTRL);
/* Set the global interrupts to be Enabled */
tmp |= (uint8_t)IOE_GIT_EN;
} else {
/* Set the global interrupts to be Disabled */
tmp &= ~(uint8_t)IOE_GIT_EN;
}
/* Write Back the Interrupt Control register */
I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_INT_CTRL, tmp);
return IOE_OK;
}
-7-
/**
* @brief Configures the selected source to generate or not a global interrupt
*
or IOE_2_ADDR.
* @param Global_IT: the interrupt source to be configured, could be:
*
*
*
*
*
*
*
*
*/
uint8_t IOE_GITConfig(uint8_t DeviceAddr, uint8_t Global_IT, FunctionalState NewState)
{
uint8_t tmp = 0;
/* Get the current value of the INT_EN register */
tmp = I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_INT_EN);
/* Set the interrupts to be Enabled */
tmp |= (uint8_t)Global_IT;
} else {
/* Set the interrupts to be Disabled */
tmp &= ~(uint8_t)Global_IT;
}
/* Set the register */
I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_INT_EN, tmp);
return IOE_OK;
}
/**
* @brief Configures the selected pins to generate an interrupt or not.
*
or IOE_2_ADDR.
* @param IO_IT: The IO interrupt to be configured. This parameter could be any
*
combination of the following values:
*
@arg IO_IT_x: where x can be from 0 to 7.
* @param NewState: could be ENABLE or DISABLE.
*/
uint8_t IOE_IOITConfig(uint8_t DeviceAddr, uint8_t IO_IT, FunctionalState NewState)
{
uint8_t tmp = 0;
tmp = I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_GPIO_INT_EN);
/* Set the interrupts to be Enabled */
tmp |= (uint8_t)IO_IT;
} else {
-8-
/* Set the interrupts to be Disabled */

tmp &= ~(uint8_t)IO_IT;
}
I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_GPIO_INT_EN, tmp);
return IOE_OK;
}
/**
* @brief Configures the touch Screen Controller (Single point detection)
* @param None
* @retval IOE_OK if all initializations are OK. Other value if error.
*/
uint8_t IOE_TS_Config(void)
{
uint8_t tmp = 0;
/* Enable TSC Fct: already done in IOE_Config */
tmp = I2C_ReadDeviceRegister(IOE_1_ADDR, IOE_REG_SYS_CTRL2);
tmp &= ~(uint32_t)(IOE_TS_FCT | IOE_ADC_FCT);
I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_SYS_CTRL2, tmp);
/* Enable the TSC global interrupts */
tmp = I2C_ReadDeviceRegister(IOE_1_ADDR, IOE_REG_INT_EN);
tmp |= (uint32_t)(IOE_GIT_TOUCH | IOE_GIT_FTH );
I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_INT_EN, tmp);
/* Select Sample Time, bit number and ADC Reference */
I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_ADC_CTRL1, 0x49);
/* Wait for ~20 ms */
_delay_(2);
/* Select the ADC clock speed: 3.25 MHz */
I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_ADC_CTRL2, 0x01);
/* Select TSC pins in non default mode */
tmp = I2C_ReadDeviceRegister(IOE_1_ADDR, IOE_REG_GPIO_AF);
tmp &= ~(uint8_t)TOUCH_IO_ALL;
I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_GPIO_AF, tmp);
/* Select 2 nF filter capacitor */
I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_TSC_CFG, 0x9A);
/* Select single point reading */
I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_FIFO_TH, 0x01);
/* Write 0x01 to clear the FIFO memory content. */
/* Write 0x00 to put the FIFO back into operation mode */
/* set the data format for Z value: 7 fractional part and 1 whole part */
-9-
I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_TSC_FRACT_XYZ, 0x01);

/* set the driving capability of the device for TSC pins: 50mA */
I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_TSC_I_DRIVE, 0x01);
/* Use no tracking index, touchscreen controller operation mode (XYZ) and
enable the TSC */
I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_TSC_CTRL, 0x01);
/* Clear all the status pending bits */
I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_INT_STA, 0xFF);
/* Initialize the TS structure to their default values */
TS_State.TouchDetected = TS_State.X = TS_State.Y = TS_State.Z = 0;
/* All configuration done */
return IOE_OK;
}
/**
* @brief Configures the selected pin to be in Alternate function or not
*
or IOE_2_ADDR.
* @param IO_Pin: IO_Pin_x, Where x can be from 0 to 7.
* @param NewState: State of the AF for the selected pin, could be
*
ENABLE or DISABLE.
*/
uint8_t IOE_IOAFConfig(uint8_t DeviceAddr, uint8_t IO_Pin, FunctionalState NewState)
{
uint8_t tmp = 0;
/* Get the current state of the GPIO_AF register */
tmp = I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_GPIO_AF);
/* Enable the selected pins alternate function */
tmp |= (uint8_t)IO_Pin;
} else {
/* Disable the selected pins alternate function */
tmp &= ~(uint8_t)IO_Pin;
}
/* Write back the new value in GPIO_AF register */
I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_GPIO_AF, tmp);
return IOE_OK;
}
/**
*
*
*
*
*
*
@brief
@param
@param
@param
Configures the Edge for which a transition is detectable for the

the selected pin.
DeviceAddr: The address of the IOExpander, could be : IOE_1_ADDR
or IOE_2_ADDR.
IO_Pin: IO_Pin_x, Where x can be from 0 to 7.
Edge: The edge which will be detected. This parameter can be one or a
-10-
*
a combination of following values: EDGE_FALLING and EDGE_RISING .
*/
uint8_t IOE_IOEdgeConfig(uint8_t DeviceAddr, uint8_t IO_Pin, uint8_t Edge)
{
uint8_t tmp1 = 0, tmp2 = 0;
/* Get the registers values */
tmp1 = I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_GPIO_FE);
tmp2 = I2C_ReadDeviceRegister(DeviceAddr, IOE_REG_GPIO_RE);
/* Disable the Falling Edge */
tmp1 &= ~(uint8_t)IO_Pin;
/* Disable the Falling Edge */
tmp2 &= ~(uint8_t)IO_Pin;
/* Enable the Falling edge if selected */
if (Edge & EDGE_FALLING) {
tmp1 |= (uint8_t)IO_Pin;
}
/* Enable the Rising edge if selected */
if (Edge & EDGE_RISING) {
tmp2 |= (uint8_t)IO_Pin;
}
/* Write back the registers values */
I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_GPIO_FE, tmp1);
I2C_WriteDeviceRegister(DeviceAddr, IOE_REG_GPIO_RE, tmp2);
/* if OK return 0 */
return IOE_OK;
}
/**
* @brief Configures the Interrupt line active state and format (level/edge)
* @param Polarity: could be
*
@arg Polarity_Low: Interrupt line is active Low/Falling edge
*
@arg Polarity_High: Interrupt line is active High/Rising edge
* @param Type: Interrupt line activity type, could be one of the following values
*
@arg Type_Level: Interrupt line is active in level model
*
@arg Type_Edge: Interrupt line is active in edge model
*/
uint8_t IOE_ITOutConfig(uint8_t Polarity, uint8_t Type)
{
uint8_t tmp = 0;
/* Get the register IOE_REG_INT_CTRL value */
tmp = I2C_ReadDeviceRegister(IOE_1_ADDR, IOE_REG_INT_CTRL);
/* Mask the polarity and type bits */
tmp &= ~(uint8_t)0x06;
/* Modify the Interrupt Output line configuration */
tmp |= (uint8_t)(Polarity | Type);
-11-

I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_INT_CTRL, tmp);
return IOE_OK;
}
/**
* @brief Writes a value in a register of the device through I2C.
*
or IOE_2_ADDR.
* @param RegisterAddr: The target register address
* @param RegisterValue: The target register value to be written
* @retval IOE_OK: if all operations are OK. Other value if error.
*/
uint8_t I2C_WriteDeviceRegister(uint8_t DeviceAddr, uint8_t RegisterAddr, uint8_t
RegisterValue)
{
uint8_t read_verif = 0;
uint8_t IOE_BufferTX = 0;
/* Get Value to be written */
IOE_BufferTX = RegisterValue;
/* Configure DMA Peripheral */
IOE_DMA_Config(IOE_DMA_TX, (uint8_t*)(&IOE_BufferTX));
/* Enable the I2C peripheral */
I2C_GenerateSTART(IOE_I2C, ENABLE);
/* Test on SB Flag */
IOE_TimeOut = TIMEOUT_MAX;
while (I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_SB) == RESET)
{
if (IOE_TimeOut-- == 0) {
}
}
/* Transmit the slave address and enable writing operation */
I2C_Send7bitAddress(IOE_I2C, DeviceAddr, I2C_Direction_Transmitter);
/* Test on ADDR Flag */
while (!I2C_CheckEvent(IOE_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
{
}
}
/* Transmit the first address for r/w operations */
I2C_SendData(IOE_I2C, RegisterAddr);
/* Test on TXE FLag (data dent) */
while ((!I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_TXE)) && (!I2C_GetFlagStatus(IOE_I2C,
-12-
I2C_FLAG_BTF)))
{
}
}
/* Enable I2C DMA request */
I2C_DMACmd(IOE_I2C,ENABLE);
/* Enable DMA TX Channel */
DMA_Cmd(IOE_DMA_TX_STREAM, ENABLE);
/* Wait until DMA Transfer Complete */
while (!DMA_GetFlagStatus(IOE_DMA_TX_STREAM,IOE_DMA_TX_TCFLAG))
{
}
}
/* Wait until BTF Flag is set before generating STOP */
IOE_TimeOut = 2 * TIMEOUT_MAX;
while ((!I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_BTF)))
{
}
/* Send STOP Condition */
I2C_GenerateSTOP(IOE_I2C, ENABLE);
/* Disable DMA TX Channel */
DMA_Cmd(IOE_DMA_TX_STREAM, DISABLE);
/* Disable I2C DMA request */
I2C_DMACmd(IOE_I2C,DISABLE);
/* Clear DMA TX Transfer Complete Flag */
DMA_ClearFlag(IOE_DMA_TX_STREAM,IOE_DMA_TX_TCFLAG);
#ifdef VERIFY_WRITTENDATA
/* Verify (if needed) that the loaded data is correct
*/
/* Read the just written register*/

read_verif = I2C_ReadDeviceRegister(DeviceAddr, RegisterAddr);
/* Load the register and verify its value */
if (read_verif != RegisterValue) {
/* Control data wrongly transfered */
read_verif = IOE_FAILURE;
} else {
/* Control data correctly transfered */
read_verif = 0;
}
#endif
/* Return the verifying value: 0 (Passed) or 1 (Failed) */
return (read_verif);
-13-
}
/**
* @brief Reads a register of the device through I2C.
* @param DeviceAddr: The address of the device, could be : IOE_1_ADDR
*
or IOE_2_ADDR.
* @param RegisterAddr: The target register address (between 00x and 0x24)
* @retval The value of the read register (0xAA if Timeout occurred)
*/
uint8_t I2C_ReadDeviceRegister(uint8_t DeviceAddr, uint8_t RegisterAddr)
{
uint8_t IOE_BufferRX[2] = {0x00, 0x00};
IOE_DMA_Config(IOE_DMA_RX, (uint8_t*)IOE_BufferRX);
/* Enable DMA NACK automatic generation */
I2C_DMALastTransferCmd(IOE_I2C, ENABLE);
while (!I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_SB))
{
}
}
/* Send device address for write */
{
}
}
/* Send the device's internal address to write to */
I2C_FLAG_BTF)))
{
}
}
/* Send START condition a second time */
-14-
{
}
}
/* Send IOExpander address for read */
I2C_Send7bitAddress(IOE_I2C, DeviceAddr, I2C_Direction_Receiver);
while (!I2C_CheckEvent(IOE_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
{
}
}
/* Enable DMA RX Channel */
DMA_Cmd(IOE_DMA_RX_STREAM, ENABLE);
while (!DMA_GetFlagStatus(IOE_DMA_RX_STREAM,IOE_DMA_RX_TCFLAG))
{
}
}
/* Disable DMA RX Channel */
DMA_Cmd(IOE_DMA_RX_STREAM, DISABLE);
/* Clear DMA RX Transfer Complete Flag */
DMA_ClearFlag(IOE_DMA_RX_STREAM,IOE_DMA_RX_TCFLAG);
/* return a pointer to the IOE_Buffer */
return (uint8_t)IOE_BufferRX[0];
}
/**
* @brief
Reads a buffer of 2 bytes from the device registers.

-15-
* @param DeviceAddr: The address of the device, could be : IOE_1_ADDR

*
or IOE_2_ADDR.
* @param RegisterAddr: The target register address (between 00x and 0x24)
* @retval A pointer to the buffer containing the two returned bytes (in halfword).
*/
uint16_t I2C_ReadDataBuffer(uint8_t DeviceAddr, uint8_t RegisterAddr)
{
uint8_t tmp= 0;
uint8_t IOE_BufferRX[2] = {0x00, 0x00};
IOE_DMA_Config(IOE_DMA_RX, (uint8_t*)IOE_BufferRX);
/* Enable DMA NACK automatic generation */
I2C_DMALastTransferCmd(IOE_I2C, ENABLE);
{
if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
}
/* Send device address for write */
{
}
}
/* Send the device's internal address to write to */
I2C_FLAG_BTF)))
{
}
}
/* Send START condition a second time */
-16-
{
}
}
/* Send IOExpander address for read */
I2C_Send7bitAddress(IOE_I2C, DeviceAddr, I2C_Direction_Receiver);
while (!I2C_CheckEvent(IOE_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
{
}
}
/* Enable DMA RX Channel */
DMA_Cmd(IOE_DMA_RX_STREAM, ENABLE);
while (!DMA_GetFlagStatus(IOE_DMA_RX_STREAM, IOE_DMA_RX_TCFLAG))
{
}
}
/* Disable DMA RX Channel */
DMA_Cmd(IOE_DMA_RX_STREAM, DISABLE);
/* Clear DMA RX Transfer Complete Flag */
DMA_ClearFlag(IOE_DMA_RX_STREAM,IOE_DMA_RX_TCFLAG);
/* Reorganize received data */
tmp = IOE_BufferRX[0];
IOE_BufferRX[0] = IOE_BufferRX[1];
IOE_BufferRX[1] = tmp;
/* return a pointer to the IOE_Buffer */
return (*(__IO uint16_t *) IOE_BufferRX);
}
/**
* @brief
* @param
Return Touch Screen X position value

None
-17-
* @retval X position.
*/
uint16_t IOE_TS_Read_X(void)
{
#if 0
int32_t x, xr;
x = I2C_ReadDataBuffer(IOE_1_ADDR, IOE_REG_TSC_DATA_X);
/*
xr
/*
xr
first correction */
= (x * 320) >> 12;
second correction */
= ((xr * 32)/29) - 17;
if (xr <= 0) {
xr = 0;
}
return (uint16_t)(xr);
#else
int32_t icount, sum = 0;
for (icount = 0; icount < 16; icount++) {
sum += I2C_ReadDataBuffer(IOE_1_ADDR, IOE_REG_TSC_DATA_X);
}
sum >>= 4;
if (sum <= 0) {
sum = 0;
}
return (uint16_t)(sum);
#endif
}
/**
* @brief Return Touch Screen Y position value
* @param None
* @retval Y position.
*/
uint16_t IOE_TS_Read_Y(void)
{
#if 0
int32_t y, yr;
y= I2C_ReadDataBuffer(IOE_1_ADDR, IOE_REG_TSC_DATA_Y);
yr= (y * 240) >> 12;
yr = ((yr * 240) / 217) - 12;
if (yr <= 0) {
yr = 0;
}
return (uint16_t)(yr);
#else
int32_t icount, sum = 0;
-18-
for (icount = 0; icount < 16; icount++) {

sum += I2C_ReadDataBuffer(IOE_1_ADDR, IOE_REG_TSC_DATA_Y);
}
sum >>= 4;
if (sum <= 0) {
sum = 0;
}
return (uint16_t)(sum);
#endif
}
/**
* @brief Return Touch Screen Z position value
* @param None
* @retval Z position.
*/
static uint16_t IOE_TS_Read_Z(void)
{
uint32_t z;
z = I2C_ReadDataBuffer(IOE_1_ADDR, IOE_REG_TSC_DATA_Z);
if (z <= 0) {
z = 0;
}
return (uint16_t)(z);
}
/**
* @brief Initializes the GPIO pins used by the IO expander.
* @param None
* @retval None
*/
static void IOE_GPIO_Config(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable IOE_I2C and IOE_I2C_GPIO_PORT & Alternate Function clocks */
RCC_APB1PeriphClockCmd(IOE_I2C_CLK, ENABLE);
RCC_AHB1PeriphClockCmd(IOE_I2C_SCL_GPIO_CLK | IOE_I2C_SDA_GPIO_CLK, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
/* Reset IOE_I2C IP */
RCC_APB1PeriphResetCmd(IOE_I2C_CLK, ENABLE);
/* Release reset signal of IOE_I2C IP */
RCC_APB1PeriphResetCmd(IOE_I2C_CLK, DISABLE);
/* IOE_I2C SCL and SDA pins configuration */
GPIO_InitStructure.GPIO_Pin = IOE_I2C_SCL_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(IOE_I2C_SCL_GPIO_PORT, &GPIO_InitStructure);
-19-
GPIO_InitStructure.GPIO_Pin = IOE_I2C_SDA_PIN;
GPIO_Init(IOE_I2C_SDA_GPIO_PORT, &GPIO_InitStructure);
GPIO_PinAFConfig(IOE_I2C_SCL_GPIO_PORT, IOE_I2C_SCL_SOURCE, IOE_I2C_SCL_AF);
GPIO_PinAFConfig(IOE_I2C_SDA_GPIO_PORT, IOE_I2C_SDA_SOURCE, IOE_I2C_SDA_AF);
}
/**
* @brief Configure the I2C Peripheral used to communicate with IO_Expanders.
* @param None
* @retval None
*/
static void IOE_I2C_Config(void)
{
I2C_InitTypeDef I2C_InitStructure;
/* IOE_I2C configuration */
I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
I2C_InitStructure.I2C_OwnAddress1 = 0x00;
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
I2C_InitStructure.I2C_ClockSpeed = I2C_SPEED;
I2C_Init(IOE_I2C, &I2C_InitStructure);
}
/**
* @brief Configure the DMA Peripheral used to handle communication via I2C.
* @param None
* @retval None
*/
static void IOE_DMA_Config(IOE_DMADirection_TypeDef Direction, uint8_t* buffer)
{
DMA_InitTypeDef DMA_InitStructure;
RCC_AHB1PeriphClockCmd(IOE_DMA_CLK, ENABLE);
/* Initialize the DMA_Channel member */
DMA_InitStructure.DMA_Channel = IOE_DMA_CHANNEL;
/* Initialize the DMA_PeripheralBaseAddr member */
DMA_InitStructure.DMA_PeripheralBaseAddr = IOE_I2C_DR;
/* Initialize the DMA_Memory0BaseAddr member */
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)buffer;
/* Initialize the DMA_PeripheralInc member */
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
/* Initialize the DMA_MemoryInc member */
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
/* Initialize the DMA_PeripheralDataSize member */
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
-20-
/* Initialize the DMA_MemoryDataSize member */

DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
/* Initialize the DMA_Mode member */
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
/* Initialize the DMA_Priority member */
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
/* Initialize the DMA_FIFOMode member */
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;
/* Initialize the DMA_FIFOThreshold member */
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_1QuarterFull;
/* Initialize the DMA_MemoryBurst member */
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
/* Initialize the DMA_PeripheralBurst member */
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
/* If using DMA for Reception */
if (Direction == IOE_DMA_RX) {
/* Initialize the DMA_DIR member */
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
/* Initialize the DMA_BufferSize member */
DMA_InitStructure.DMA_BufferSize = 2;
DMA_DeInit(IOE_DMA_RX_STREAM);
DMA_Init(IOE_DMA_RX_STREAM, &DMA_InitStructure);
}
/* If using DMA for Transmission */
else if (Direction == IOE_DMA_TX) {
/* Initialize the DMA_DIR member */
DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
/* Initialize the DMA_BufferSize member */
DMA_InitStructure.DMA_BufferSize = 1;
DMA_DeInit(IOE_DMA_TX_STREAM);
DMA_Init(IOE_DMA_TX_STREAM, &DMA_InitStructure);
}
}
/**
* @brief
* @param
* @retval
*/
static void
{
#if 0
Configures the IO expander Interrupt line and GPIO in EXTI mode.

None
None
IOE_EXTI_Config(void)
-21-
GPIO_InitTypeDef GPIO_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
/* Enable GPIO clock */
RCC_AHB1PeriphClockCmd(IOE_IT_GPIO_CLK, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
/* Configure Button pin as input floating */
GPIO_InitStructure.GPIO_Pin = IOE_IT_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(IOE_IT_GPIO_PORT, &GPIO_InitStructure);
/* Connect Button EXTI Line to Button GPIO Pin */
SYSCFG_EXTILineConfig(IOE_IT_EXTI_PORT_SOURCE, IOE_IT_EXTI_PIN_SOURCE);
/* Configure Button EXTI line */
EXTI_InitStructure.EXTI_Line = IOE_IT_EXTI_LINE;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
/* Enable and set Button EXTI Interrupt to the lowest priority */
NVIC_InitStructure.NVIC_IRQChannel = IOE_IT_EXTI_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
#endif
}
#ifndef USE_Delay
/**
* @brief Inserts a delay time.
* @param nCount: specifies the delay time length.
* @retval None
*/
static void delay(__IO uint32_t nCount)
{
__IO uint32_t index = 0;
for(index = (100000 * nCount); index != 0; index--)
{
}
}
#endif /* USE_Delay*/
/**
* @}
*/
/**
* @}
*/
/**
* @}
-22-
*/
/**
* @}
*/
/**
* @}
*/
/******************** COPYRIGHT 2012 Embest Tech. Co., Ltd.*****END OF FILE****/
-23-

Stmpe811qtr C

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Stmpe811qtr C

Uploaded by

Copyright:

Available Formats

H:\y4_LCD_TFT\0_utility\STemWin\ProgettoLCDProvaWork\Project\STMPE811QTR.

venerd 16 gennaio 2015 15:50

/** @defgroup STM32F4_DISCOVERY_IOE_Private_Variables

/** @defgroup STM32F4_DISCOVERY_IOE_Private_FunctionPrototypes

venerd 16 gennaio 2015 15:50

/** @defgroup STM32F4_DISCOVERY_IOE_Private_Functions

venerd 16 gennaio 2015 15:50

if (IOE_ITSRC_Source & IOE_ITSRC_TSC) {

venerd 16 gennaio 2015 15:50

Checks the status of the selected IO interrupt pending bit

venerd 16 gennaio 2015 15:50

venerd 16 gennaio 2015 15:50

/* If all OK return IOE_OK */

venerd 16 gennaio 2015 15:50

venerd 16 gennaio 2015 15:50

venerd 16 gennaio 2015 15:50

/* Set the interrupts to be Disabled */

venerd 16 gennaio 2015 15:50

I2C_WriteDeviceRegister(IOE_1_ADDR, IOE_REG_TSC_FRACT_XYZ, 0x01);

Configures the Edge for which a transition is detectable for the

venerd 16 gennaio 2015 15:50

venerd 16 gennaio 2015 15:50

/* Set the register */

venerd 16 gennaio 2015 15:50

/* Read the just written register*/

venerd 16 gennaio 2015 15:50

Reads a buffer of 2 bytes from the device registers.

venerd 16 gennaio 2015 15:50

venerd 16 gennaio 2015 15:50

* @param DeviceAddr: The address of the device, could be : IOE_1_ADDR

Return Touch Screen X position value

venerd 16 gennaio 2015 15:50

venerd 16 gennaio 2015 15:50

for (icount = 0; icount < 16; icount++) {

venerd 16 gennaio 2015 15:50

venerd 16 gennaio 2015 15:50

/* Initialize the DMA_MemoryDataSize member */

Configures the IO expander Interrupt line and GPIO in EXTI mode.

venerd 16 gennaio 2015 15:50

venerd 16 gennaio 2015 15:50

venerd 16 gennaio 2015 15:50

You might also like