diff options
Diffstat (limited to 'tmp/STM32F10x_StdPeriph_Lib_V3.5.0/Utilities/STM32_EVAL/STM32100B_EVAL')
6 files changed, 5245 insertions, 0 deletions
diff --git a/tmp/STM32F10x_StdPeriph_Lib_V3.5.0/Utilities/STM32_EVAL/STM32100B_EVAL/stm32100b_eval.c b/tmp/STM32F10x_StdPeriph_Lib_V3.5.0/Utilities/STM32_EVAL/STM32100B_EVAL/stm32100b_eval.c new file mode 100644 index 0000000..947329d --- /dev/null +++ b/tmp/STM32F10x_StdPeriph_Lib_V3.5.0/Utilities/STM32_EVAL/STM32100B_EVAL/stm32100b_eval.c @@ -0,0 +1,624 @@ +/** + ****************************************************************************** + * @file stm32100b_eval.c + * @author MCD Application Team + * @version V4.5.0 + * @date 07-March-2011 + * @brief This file provides + * - set of firmware functions to manage Leds, push-button and COM ports + * - low level initialization functions for SD card (on SPI), SPI serial + * flash (sFLASH) and temperature sensor (LM75) + * available on STM32100B-EVAL evaluation board from STMicroelectronics. + ****************************************************************************** + * @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, STMICROELECTRONICS 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. + * + * <h2><center>© COPYRIGHT 2011 STMicroelectronics</center></h2> + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32100b_eval.h" +#include "stm32f10x_spi.h" +#include "stm32f10x_i2c.h" + +/** @addtogroup Utilities + * @{ + */ + +/** @addtogroup STM32_EVAL + * @{ + */ + +/** @addtogroup STM32100B_EVAL + * @{ + */ + +/** @defgroup STM32100B_EVAL_LOW_LEVEL + * @brief This file provides firmware functions to manage Leds, push-buttons, + * COM ports, SD card on SPI, serial flash (sFLASH) and temperature + * sensor (LM75) available on STM32100B-EVAL evaluation board from + * STMicroelectronics. + * @{ + */ + +/** @defgroup STM32100B_EVAL_LOW_LEVEL_Private_TypesDefinitions + * @{ + */ +/** + * @} + */ + + +/** @defgroup STM32100B_EVAL_LOW_LEVEL_Private_Defines + * @{ + */ +/** + * @} + */ + + +/** @defgroup STM32100B_EVAL_LOW_LEVEL_Private_Macros + * @{ + */ +/** + * @} + */ + + +/** @defgroup STM32100B_EVAL_LOW_LEVEL_Private_Variables + * @{ + */ +GPIO_TypeDef* GPIO_PORT[LEDn] = {LED1_GPIO_PORT, LED2_GPIO_PORT, LED3_GPIO_PORT, + LED4_GPIO_PORT}; +const uint16_t GPIO_PIN[LEDn] = {LED1_PIN, LED2_PIN, LED3_PIN, + LED4_PIN}; +const uint32_t GPIO_CLK[LEDn] = {LED1_GPIO_CLK, LED2_GPIO_CLK, LED3_GPIO_CLK, + LED4_GPIO_CLK}; + +GPIO_TypeDef* BUTTON_PORT[BUTTONn] = {WAKEUP_BUTTON_GPIO_PORT, TAMPER_BUTTON_GPIO_PORT, + KEY_BUTTON_GPIO_PORT, RIGHT_BUTTON_GPIO_PORT, + LEFT_BUTTON_GPIO_PORT, UP_BUTTON_GPIO_PORT, + DOWN_BUTTON_GPIO_PORT, SEL_BUTTON_GPIO_PORT}; + +const uint16_t BUTTON_PIN[BUTTONn] = {WAKEUP_BUTTON_PIN, TAMPER_BUTTON_PIN, + KEY_BUTTON_PIN, RIGHT_BUTTON_PIN, + LEFT_BUTTON_PIN, UP_BUTTON_PIN, + DOWN_BUTTON_PIN, SEL_BUTTON_PIN}; + +const uint32_t BUTTON_CLK[BUTTONn] = {WAKEUP_BUTTON_GPIO_CLK, TAMPER_BUTTON_GPIO_CLK, + KEY_BUTTON_GPIO_CLK, RIGHT_BUTTON_GPIO_CLK, + LEFT_BUTTON_GPIO_CLK, UP_BUTTON_GPIO_CLK, + DOWN_BUTTON_GPIO_CLK, SEL_BUTTON_GPIO_CLK}; + +const uint16_t BUTTON_EXTI_LINE[BUTTONn] = {WAKEUP_BUTTON_EXTI_LINE, + TAMPER_BUTTON_EXTI_LINE, + KEY_BUTTON_EXTI_LINE, + RIGHT_BUTTON_EXTI_LINE, + LEFT_BUTTON_EXTI_LINE, + UP_BUTTON_EXTI_LINE, + DOWN_BUTTON_EXTI_LINE, + SEL_BUTTON_EXTI_LINE}; + +const uint16_t BUTTON_PORT_SOURCE[BUTTONn] = {WAKEUP_BUTTON_EXTI_PORT_SOURCE, + TAMPER_BUTTON_EXTI_PORT_SOURCE, + KEY_BUTTON_EXTI_PORT_SOURCE, + RIGHT_BUTTON_EXTI_PORT_SOURCE, + LEFT_BUTTON_EXTI_PORT_SOURCE, + UP_BUTTON_EXTI_PORT_SOURCE, + DOWN_BUTTON_EXTI_PORT_SOURCE, + SEL_BUTTON_EXTI_PORT_SOURCE}; + +const uint16_t BUTTON_PIN_SOURCE[BUTTONn] = {WAKEUP_BUTTON_EXTI_PIN_SOURCE, + TAMPER_BUTTON_EXTI_PIN_SOURCE, + KEY_BUTTON_EXTI_PIN_SOURCE, + RIGHT_BUTTON_EXTI_PIN_SOURCE, + LEFT_BUTTON_EXTI_PIN_SOURCE, + UP_BUTTON_EXTI_PIN_SOURCE, + DOWN_BUTTON_EXTI_PIN_SOURCE, + SEL_BUTTON_EXTI_PIN_SOURCE}; + +const uint16_t BUTTON_IRQn[BUTTONn] = {WAKEUP_BUTTON_EXTI_IRQn, TAMPER_BUTTON_EXTI_IRQn, + KEY_BUTTON_EXTI_IRQn, RIGHT_BUTTON_EXTI_IRQn, + LEFT_BUTTON_EXTI_IRQn, UP_BUTTON_EXTI_IRQn, + DOWN_BUTTON_EXTI_IRQn, SEL_BUTTON_EXTI_IRQn}; + +USART_TypeDef* COM_USART[COMn] = {EVAL_COM1, EVAL_COM2}; + +GPIO_TypeDef* COM_TX_PORT[COMn] = {EVAL_COM1_TX_GPIO_PORT, EVAL_COM2_TX_GPIO_PORT}; + +GPIO_TypeDef* COM_RX_PORT[COMn] = {EVAL_COM1_RX_GPIO_PORT, EVAL_COM2_RX_GPIO_PORT}; + +const uint32_t COM_USART_CLK[COMn] = {EVAL_COM1_CLK, EVAL_COM2_CLK}; + +const uint32_t COM_TX_PORT_CLK[COMn] = {EVAL_COM1_TX_GPIO_CLK, EVAL_COM2_TX_GPIO_CLK}; + +const uint32_t COM_RX_PORT_CLK[COMn] = {EVAL_COM1_RX_GPIO_CLK, EVAL_COM2_RX_GPIO_CLK}; + +const uint16_t COM_TX_PIN[COMn] = {EVAL_COM1_TX_PIN, EVAL_COM2_TX_PIN}; + +const uint16_t COM_RX_PIN[COMn] = {EVAL_COM1_RX_PIN, EVAL_COM2_RX_PIN}; + +/** + * @} + */ + + +/** @defgroup STM32100B_EVAL_LOW_LEVEL_Private_FunctionPrototypes + * @{ + */ + +/** + * @} + */ + + +/** @defgroup STM32100B_EVAL_LOW_LEVEL_Private_Functions + * @{ + */ + +/** + * @brief Configures LED GPIO. + * @param Led: Specifies the Led to be configured. + * This parameter can be one of following parameters: + * @arg LED1 + * @arg LED2 + * @arg LED3 + * @arg LED4 + * @retval None + */ +void STM_EVAL_LEDInit(Led_TypeDef Led) +{ + GPIO_InitTypeDef GPIO_InitStructure; + + /* Enable the GPIO_LED Clock */ + RCC_APB2PeriphClockCmd(GPIO_CLK[Led], ENABLE); + + /* Configure the GPIO_LED pin */ + GPIO_InitStructure.GPIO_Pin = GPIO_PIN[Led]; + + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; + GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; + GPIO_Init(GPIO_PORT[Led], &GPIO_InitStructure); +} + +/** + * @brief Turns selected LED On. + * @param Led: Specifies the Led to be set on. + * This parameter can be one of following parameters: + * @arg LED1 + * @arg LED2 + * @arg LED3 + * @arg LED4 + * @retval None + */ +void STM_EVAL_LEDOn(Led_TypeDef Led) +{ + GPIO_PORT[Led]->BSRR = GPIO_PIN[Led]; +} + +/** + * @brief Turns selected LED Off. + * @param Led: Specifies the Led to be set off. + * This parameter can be one of following parameters: + * @arg LED1 + * @arg LED2 + * @arg LED3 + * @arg LED4 + * @retval None + */ +void STM_EVAL_LEDOff(Led_TypeDef Led) +{ + GPIO_PORT[Led]->BRR = GPIO_PIN[Led]; +} + +/** + * @brief Toggles the selected LED. + * @param Led: Specifies the Led to be toggled. + * This parameter can be one of following parameters: + * @arg LED1 + * @arg LED2 + * @arg LED3 + * @arg LED4 + * @retval None + */ +void STM_EVAL_LEDToggle(Led_TypeDef Led) +{ + GPIO_PORT[Led]->ODR ^= GPIO_PIN[Led]; +} + +/** + * @brief Configures Button GPIO and EXTI Line. + * @param Button: Specifies the Button to be configured. + * This parameter can be one of following parameters: + * @arg BUTTON_WAKEUP: Wakeup Push Button + * @arg BUTTON_TAMPER: Tamper Push Button + * @arg BUTTON_KEY: Key Push Button + * @arg BUTTON_RIGHT: Joystick Right Push Button + * @arg BUTTON_LEFT: Joystick Left Push Button + * @arg BUTTON_UP: Joystick Up Push Button + * @arg BUTTON_DOWN: Joystick Down Push Button + * @arg BUTTON_SEL: Joystick Sel Push Button + * @param Button_Mode: Specifies Button mode. + * This parameter can be one of following parameters: + * @arg BUTTON_MODE_GPIO: Button will be used as simple IO + * @arg BUTTON_MODE_EXTI: Button will be connected to EXTI line with interrupt + * generation capability + * @retval None + */ +void STM_EVAL_PBInit(Button_TypeDef Button, ButtonMode_TypeDef Button_Mode) +{ + GPIO_InitTypeDef GPIO_InitStructure; + EXTI_InitTypeDef EXTI_InitStructure; + NVIC_InitTypeDef NVIC_InitStructure; + + /* Enable the BUTTON Clock */ + RCC_APB2PeriphClockCmd(BUTTON_CLK[Button] | RCC_APB2Periph_AFIO, ENABLE); + + /* Configure Button pin as input floating */ + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; + GPIO_InitStructure.GPIO_Pin = BUTTON_PIN[Button]; + GPIO_Init(BUTTON_PORT[Button], &GPIO_InitStructure); + + + if (Button_Mode == BUTTON_MODE_EXTI) + { + /* Connect Button EXTI Line to Button GPIO Pin */ + GPIO_EXTILineConfig(BUTTON_PORT_SOURCE[Button], BUTTON_PIN_SOURCE[Button]); + + /* Configure Button EXTI line */ + EXTI_InitStructure.EXTI_Line = BUTTON_EXTI_LINE[Button]; + EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt; + + if(Button != BUTTON_WAKEUP) + { + EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; + } + else + { + EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising; + } + EXTI_InitStructure.EXTI_LineCmd = ENABLE; + EXTI_Init(&EXTI_InitStructure); + + /* Enable and set Button EXTI Interrupt to the lowest priority */ + NVIC_InitStructure.NVIC_IRQChannel = BUTTON_IRQn[Button]; + NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F; + NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F; + NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; + + NVIC_Init(&NVIC_InitStructure); + } +} + +/** + * @brief Returns the selected Button state. + * @param Button: Specifies the Button to be checked. + * This parameter can be one of following parameters: + * @arg BUTTON_WAKEUP: Wakeup Push Button + * @arg BUTTON_TAMPER: Tamper Push Button + * @arg BUTTON_KEY: Key Push Button + * @arg BUTTON_RIGHT: Joystick Right Push Button + * @arg BUTTON_LEFT: Joystick Left Push Button + * @arg BUTTON_UP: Joystick Up Push Button + * @arg BUTTON_DOWN: Joystick Down Push Button + * @arg BUTTON_SEL: Joystick Sel Push Button + * @retval The Button GPIO pin value. + */ +uint32_t STM_EVAL_PBGetState(Button_TypeDef Button) +{ + return GPIO_ReadInputDataBit(BUTTON_PORT[Button], BUTTON_PIN[Button]); +} + + +/** + * @brief Configures COM port. + * @param COM: Specifies the COM port to be configured. + * This parameter can be one of following parameters: + * @arg COM1 + * @arg COM2 + * @param USART_InitStruct: pointer to a USART_InitTypeDef structure that + * contains the configuration information for the specified USART peripheral. + * @retval None + */ +void STM_EVAL_COMInit(COM_TypeDef COM, USART_InitTypeDef* USART_InitStruct) +{ + GPIO_InitTypeDef GPIO_InitStructure; + + /* Enable GPIO clock */ + RCC_APB2PeriphClockCmd(COM_TX_PORT_CLK[COM] | COM_RX_PORT_CLK[COM] | RCC_APB2Periph_AFIO, ENABLE); + + + /* Enable UART clock */ + if (COM == COM1) + { + RCC_APB2PeriphClockCmd(COM_USART_CLK[COM], ENABLE); + } + else + { + /* Enable the USART2 Pins Software Remapping */ + GPIO_PinRemapConfig(GPIO_Remap_USART2, ENABLE); + RCC_APB1PeriphClockCmd(COM_USART_CLK[COM], ENABLE); + } + + /* Configure USART Tx as alternate function push-pull */ + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; + GPIO_InitStructure.GPIO_Pin = COM_TX_PIN[COM]; + GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; + GPIO_Init(COM_TX_PORT[COM], &GPIO_InitStructure); + + /* Configure USART Rx as input floating */ + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; + GPIO_InitStructure.GPIO_Pin = COM_RX_PIN[COM]; + GPIO_Init(COM_RX_PORT[COM], &GPIO_InitStructure); + + /* USART configuration */ + USART_Init(COM_USART[COM], USART_InitStruct); + + /* Enable USART */ + USART_Cmd(COM_USART[COM], ENABLE); +} + +/** + * @brief DeInitializes the SD/SD communication. + * @param None + * @retval None + */ +void SD_LowLevel_DeInit(void) +{ + GPIO_InitTypeDef GPIO_InitStructure; + + SPI_Cmd(SD_SPI, DISABLE); /*!< SD_SPI disable */ + SPI_I2S_DeInit(SD_SPI); /*!< DeInitializes the SD_SPI */ + + /*!< SD_SPI Periph clock disable */ + RCC_APB2PeriphClockCmd(SD_SPI_CLK, DISABLE); + + /*!< Configure SD_SPI pins: SCK */ + GPIO_InitStructure.GPIO_Pin = SD_SPI_SCK_PIN; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; + GPIO_Init(SD_SPI_SCK_GPIO_PORT, &GPIO_InitStructure); + + /*!< Configure SD_SPI pins: MISO */ + GPIO_InitStructure.GPIO_Pin = SD_SPI_MISO_PIN; + GPIO_Init(SD_SPI_MISO_GPIO_PORT, &GPIO_InitStructure); + + /*!< Configure SD_SPI pins: MOSI */ + GPIO_InitStructure.GPIO_Pin = SD_SPI_MOSI_PIN; + GPIO_Init(SD_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure); + + /*!< Configure SD_SPI_CS_PIN pin: SD Card CS pin */ + GPIO_InitStructure.GPIO_Pin = SD_CS_PIN; + GPIO_Init(SD_CS_GPIO_PORT, &GPIO_InitStructure); + + /*!< Configure SD_SPI_DETECT_PIN pin: SD Card detect pin */ + GPIO_InitStructure.GPIO_Pin = SD_DETECT_PIN; + GPIO_Init(SD_DETECT_GPIO_PORT, &GPIO_InitStructure); +} + +/** + * @brief Initializes the SD_SPI and CS pins. + * @param None + * @retval None + */ +void SD_LowLevel_Init(void) +{ + GPIO_InitTypeDef GPIO_InitStructure; + SPI_InitTypeDef SPI_InitStructure; + + /*!< SD_SPI_CS_GPIO, SD_SPI_MOSI_GPIO, SD_SPI_MISO_GPIO, SD_SPI_DETECT_GPIO + and SD_SPI_SCK_GPIO Periph clock enable */ + RCC_APB2PeriphClockCmd(SD_CS_GPIO_CLK | SD_SPI_MOSI_GPIO_CLK | SD_SPI_MISO_GPIO_CLK | + SD_SPI_SCK_GPIO_CLK | SD_DETECT_GPIO_CLK, ENABLE); + + /*!< SD_SPI Periph clock enable */ + RCC_APB2PeriphClockCmd(SD_SPI_CLK, ENABLE); + + + /*!< Configure SD_SPI pins: SCK */ + GPIO_InitStructure.GPIO_Pin = SD_SPI_SCK_PIN; + GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; + GPIO_Init(SD_SPI_SCK_GPIO_PORT, &GPIO_InitStructure); + + /*!< Configure SD_SPI pins: MOSI */ + GPIO_InitStructure.GPIO_Pin = SD_SPI_MOSI_PIN; + GPIO_Init(SD_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure); + + /*!< Configure SD_SPI pins: MISO */ + GPIO_InitStructure.GPIO_Pin = SD_SPI_MISO_PIN; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; + GPIO_Init(SD_SPI_MISO_GPIO_PORT, &GPIO_InitStructure); + + /*!< Configure SD_SPI_CS_PIN pin: SD Card CS pin */ + GPIO_InitStructure.GPIO_Pin = SD_CS_PIN; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; + GPIO_Init(SD_CS_GPIO_PORT, &GPIO_InitStructure); + + /*!< Configure SD_SPI_DETECT_PIN pin: SD Card detect pin */ + GPIO_InitStructure.GPIO_Pin = SD_DETECT_PIN; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; + GPIO_Init(SD_DETECT_GPIO_PORT, &GPIO_InitStructure); + + /*!< SD_SPI Config */ + SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; + SPI_InitStructure.SPI_Mode = SPI_Mode_Master; + SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b; + SPI_InitStructure.SPI_CPOL = SPI_CPOL_High; + SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge; + SPI_InitStructure.SPI_NSS = SPI_NSS_Soft; + SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2; + + SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; + SPI_InitStructure.SPI_CRCPolynomial = 7; + SPI_Init(SD_SPI, &SPI_InitStructure); + + SPI_Cmd(SD_SPI, ENABLE); /*!< SD_SPI enable */ +} + +/** + * @brief DeInitializes the peripherals used by the SPI FLASH driver. + * @param None + * @retval None + */ +void sFLASH_LowLevel_DeInit(void) +{ + GPIO_InitTypeDef GPIO_InitStructure; + + /*!< Disable the sFLASH_SPI */ + SPI_Cmd(sFLASH_SPI, DISABLE); + + /*!< DeInitializes the sFLASH_SPI */ + SPI_I2S_DeInit(sFLASH_SPI); + + /*!< sFLASH_SPI Periph clock disable */ + RCC_APB2PeriphClockCmd(sFLASH_SPI_CLK, DISABLE); + + /*!< Configure sFLASH_SPI pins: SCK */ + GPIO_InitStructure.GPIO_Pin = sFLASH_SPI_SCK_PIN; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; + GPIO_Init(sFLASH_SPI_SCK_GPIO_PORT, &GPIO_InitStructure); + + /*!< Configure sFLASH_SPI pins: MISO */ + GPIO_InitStructure.GPIO_Pin = sFLASH_SPI_MISO_PIN; + GPIO_Init(sFLASH_SPI_MISO_GPIO_PORT, &GPIO_InitStructure); + + /*!< Configure sFLASH_SPI pins: MOSI */ + GPIO_InitStructure.GPIO_Pin = sFLASH_SPI_MOSI_PIN; + GPIO_Init(sFLASH_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure); + + /*!< Configure sFLASH_CS_PIN pin: sFLASH Card CS pin */ + GPIO_InitStructure.GPIO_Pin = sFLASH_CS_PIN; + GPIO_Init(sFLASH_CS_GPIO_PORT, &GPIO_InitStructure); +} + +/** + * @brief Initializes the peripherals used by the SPI FLASH driver. + * @param None + * @retval None + */ +void sFLASH_LowLevel_Init(void) +{ + GPIO_InitTypeDef GPIO_InitStructure; + + /*!< sFLASH_SPI_CS_GPIO, sFLASH_SPI_MOSI_GPIO, sFLASH_SPI_MISO_GPIO + and sFLASH_SPI_SCK_GPIO Periph clock enable */ + RCC_APB2PeriphClockCmd(sFLASH_CS_GPIO_CLK | sFLASH_SPI_MOSI_GPIO_CLK | sFLASH_SPI_MISO_GPIO_CLK | + sFLASH_SPI_SCK_GPIO_CLK, ENABLE); + + /*!< sFLASH_SPI Periph clock enable */ + RCC_APB2PeriphClockCmd(sFLASH_SPI_CLK, ENABLE); + + /*!< Configure sFLASH_SPI pins: SCK */ + GPIO_InitStructure.GPIO_Pin = sFLASH_SPI_SCK_PIN; + GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; + GPIO_Init(sFLASH_SPI_SCK_GPIO_PORT, &GPIO_InitStructure); + + /*!< Configure sFLASH_SPI pins: MOSI */ + GPIO_InitStructure.GPIO_Pin = sFLASH_SPI_MOSI_PIN; + GPIO_Init(sFLASH_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure); + + /*!< Configure sFLASH_SPI pins: MISO */ + GPIO_InitStructure.GPIO_Pin = sFLASH_SPI_MISO_PIN; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; + GPIO_Init(sFLASH_SPI_MISO_GPIO_PORT, &GPIO_InitStructure); + + /*!< Configure sFLASH_CS_PIN pin: sFLASH Card CS pin */ + GPIO_InitStructure.GPIO_Pin = sFLASH_CS_PIN; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; + GPIO_Init(sFLASH_CS_GPIO_PORT, &GPIO_InitStructure); +} + +/** + * @brief DeInitializes the LM75_I2C. + * @param None + * @retval None + */ +void LM75_LowLevel_DeInit(void) +{ + GPIO_InitTypeDef GPIO_InitStructure; + + /*!< Disable LM75_I2C */ + I2C_Cmd(LM75_I2C, DISABLE); + /*!< DeInitializes the LM75_I2C */ + I2C_DeInit(LM75_I2C); + + /*!< LM75_I2C Periph clock disable */ + RCC_APB1PeriphClockCmd(LM75_I2C_CLK, DISABLE); + + /*!< Configure LM75_I2C pins: SCL */ + GPIO_InitStructure.GPIO_Pin = LM75_I2C_SCL_PIN; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; + GPIO_Init(LM75_I2C_SCL_GPIO_PORT, &GPIO_InitStructure); + + /*!< Configure LM75_I2C pins: SDA */ + GPIO_InitStructure.GPIO_Pin = LM75_I2C_SDA_PIN; + GPIO_Init(LM75_I2C_SDA_GPIO_PORT, &GPIO_InitStructure); + + /*!< Configure LM75_I2C pin: SMBUS ALERT */ + GPIO_InitStructure.GPIO_Pin = LM75_I2C_SMBUSALERT_PIN; + GPIO_Init(LM75_I2C_SMBUSALERT_GPIO_PORT, &GPIO_InitStructure); +} + +/** + * @brief Initializes the LM75_I2C.. + * @param None + * @retval None + */ +void LM75_LowLevel_Init(void) +{ + GPIO_InitTypeDef GPIO_InitStructure; + + /*!< LM75_I2C Periph clock enable */ + RCC_APB1PeriphClockCmd(LM75_I2C_CLK, ENABLE); + + /*!< LM75_I2C_SCL_GPIO_CLK, LM75_I2C_SDA_GPIO_CLK + and LM75_I2C_SMBUSALERT_GPIO_CLK Periph clock enable */ + RCC_APB2PeriphClockCmd(LM75_I2C_SCL_GPIO_CLK | LM75_I2C_SDA_GPIO_CLK | + LM75_I2C_SMBUSALERT_GPIO_CLK, ENABLE); + + /*!< Configure LM75_I2C pins: SCL */ + GPIO_InitStructure.GPIO_Pin = LM75_I2C_SCL_PIN; + GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD; + GPIO_Init(LM75_I2C_SCL_GPIO_PORT, &GPIO_InitStructure); + + /*!< Configure LM75_I2C pins: SDA */ + GPIO_InitStructure.GPIO_Pin = LM75_I2C_SDA_PIN; + GPIO_Init(LM75_I2C_SDA_GPIO_PORT, &GPIO_InitStructure); + + /*!< Configure LM75_I2C pin: SMBUS ALERT */ + GPIO_InitStructure.GPIO_Pin = LM75_I2C_SMBUSALERT_PIN; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; + GPIO_Init(LM75_I2C_SMBUSALERT_GPIO_PORT, &GPIO_InitStructure); +} + +/** + * @} + */ + + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/ diff --git a/tmp/STM32F10x_StdPeriph_Lib_V3.5.0/Utilities/STM32_EVAL/STM32100B_EVAL/stm32100b_eval.h b/tmp/STM32F10x_StdPeriph_Lib_V3.5.0/Utilities/STM32_EVAL/STM32100B_EVAL/stm32100b_eval.h new file mode 100644 index 0000000..b6c4ccb --- /dev/null +++ b/tmp/STM32F10x_StdPeriph_Lib_V3.5.0/Utilities/STM32_EVAL/STM32100B_EVAL/stm32100b_eval.h @@ -0,0 +1,341 @@ +/** + ****************************************************************************** + * @file stm32100b_eval.h + * @author MCD Application Team + * @version V4.5.0 + * @date 07-March-2011 + * @brief This file contains definitions for STM32100B_EVAL's Leds, push-buttons + * COM ports, SD Card on SPI, sFLASH on SPI and Temperature Sensor LM75 on I2C + * hardware resources. + ****************************************************************************** + * @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, STMICROELECTRONICS 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. + * + * <h2><center>© COPYRIGHT 2011 STMicroelectronics</center></h2> + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32100B_EVAL_H +#define __STM32100B_EVAL_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32_eval.h" + +/** @addtogroup Utilities + * @{ + */ + +/** @addtogroup STM32_EVAL + * @{ + */ + +/** @addtogroup STM32100B_EVAL + * @{ + */ + +/** @addtogroup STM32100B_EVAL_LOW_LEVEL + * @{ + */ + +/** @defgroup STM32100B_EVAL_LOW_LEVEL_Exported_Types + * @{ + */ +/** + * @} + */ + +/** @defgroup STM32100B_EVAL_LOW_LEVEL_Exported_Constants + * @{ + */ +/** @addtogroup STM32100B_EVAL_LOW_LEVEL_LED + * @{ + */ +#define LEDn 4 +#define LED1_PIN GPIO_Pin_6 +#define LED1_GPIO_PORT GPIOC +#define LED1_GPIO_CLK RCC_APB2Periph_GPIOC + +#define LED2_PIN GPIO_Pin_7 +#define LED2_GPIO_PORT GPIOC +#define LED2_GPIO_CLK RCC_APB2Periph_GPIOC + +#define LED3_PIN GPIO_Pin_8 +#define LED3_GPIO_PORT GPIOC +#define LED3_GPIO_CLK RCC_APB2Periph_GPIOC + +#define LED4_PIN GPIO_Pin_9 +#define LED4_GPIO_PORT GPIOC +#define LED4_GPIO_CLK RCC_APB2Periph_GPIOC + +/** + * @} + */ + +/** @addtogroup STM32100B_EVAL_LOW_LEVEL_BUTTON + * @{ + */ +#define BUTTONn 8 + +/** + * @brief Wakeup push-button + */ +#define WAKEUP_BUTTON_PIN GPIO_Pin_0 +#define WAKEUP_BUTTON_GPIO_PORT GPIOA +#define WAKEUP_BUTTON_GPIO_CLK RCC_APB2Periph_GPIOA +#define WAKEUP_BUTTON_EXTI_LINE EXTI_Line0 +#define WAKEUP_BUTTON_EXTI_PORT_SOURCE GPIO_PortSourceGPIOA +#define WAKEUP_BUTTON_EXTI_PIN_SOURCE GPIO_PinSource0 +#define WAKEUP_BUTTON_EXTI_IRQn EXTI0_IRQn +/** + * @brief Tamper push-button + */ +#define TAMPER_BUTTON_PIN GPIO_Pin_13 +#define TAMPER_BUTTON_GPIO_PORT GPIOC +#define TAMPER_BUTTON_GPIO_CLK RCC_APB2Periph_GPIOC +#define TAMPER_BUTTON_EXTI_LINE EXTI_Line13 +#define TAMPER_BUTTON_EXTI_PORT_SOURCE GPIO_PortSourceGPIOC +#define TAMPER_BUTTON_EXTI_PIN_SOURCE GPIO_PinSource13 +#define TAMPER_BUTTON_EXTI_IRQn EXTI15_10_IRQn +/** + * @brief Key push-button + */ +#define KEY_BUTTON_PIN GPIO_Pin_9 +#define KEY_BUTTON_GPIO_PORT GPIOB +#define KEY_BUTTON_GPIO_CLK RCC_APB2Periph_GPIOB +#define KEY_BUTTON_EXTI_LINE EXTI_Line9 +#define KEY_BUTTON_EXTI_PORT_SOURCE GPIO_PortSourceGPIOB +#define KEY_BUTTON_EXTI_PIN_SOURCE GPIO_PinSource9 +#define KEY_BUTTON_EXTI_IRQn EXTI9_5_IRQn +/** + * @brief Joystick Right push-button + */ +#define RIGHT_BUTTON_PIN GPIO_Pin_1 +#define RIGHT_BUTTON_GPIO_PORT GPIOE +#define RIGHT_BUTTON_GPIO_CLK RCC_APB2Periph_GPIOE +#define RIGHT_BUTTON_EXTI_LINE EXTI_Line1 +#define RIGHT_BUTTON_EXTI_PORT_SOURCE GPIO_PortSourceGPIOE +#define RIGHT_BUTTON_EXTI_PIN_SOURCE GPIO_PinSource1 +#define RIGHT_BUTTON_EXTI_IRQn EXTI1_IRQn +/** + * @brief Joystick Left push-button + */ +#define LEFT_BUTTON_PIN GPIO_Pin_0 +#define LEFT_BUTTON_GPIO_PORT GPIOE +#define LEFT_BUTTON_GPIO_CLK RCC_APB2Periph_GPIOE +#define LEFT_BUTTON_EXTI_LINE EXTI_Line0 +#define LEFT_BUTTON_EXTI_PORT_SOURCE GPIO_PortSourceGPIOE +#define LEFT_BUTTON_EXTI_PIN_SOURCE GPIO_PinSource0 +#define LEFT_BUTTON_EXTI_IRQn EXTI0_IRQn +/** + * @brief Joystick Up push-button + */ +#define UP_BUTTON_PIN GPIO_Pin_8 +#define UP_BUTTON_GPIO_PORT GPIOD +#define UP_BUTTON_GPIO_CLK RCC_APB2Periph_GPIOD +#define UP_BUTTON_EXTI_LINE EXTI_Line8 +#define UP_BUTTON_EXTI_PORT_SOURCE GPIO_PortSourceGPIOD +#define UP_BUTTON_EXTI_PIN_SOURCE GPIO_PinSource8 +#define UP_BUTTON_EXTI_IRQn EXTI9_5_IRQn +/** + * @brief Joystick Down push-button + */ +#define DOWN_BUTTON_PIN GPIO_Pin_14 +#define DOWN_BUTTON_GPIO_PORT GPIOD +#define DOWN_BUTTON_GPIO_CLK RCC_APB2Periph_GPIOD +#define DOWN_BUTTON_EXTI_LINE EXTI_Line14 +#define DOWN_BUTTON_EXTI_PORT_SOURCE GPIO_PortSourceGPIOD +#define DOWN_BUTTON_EXTI_PIN_SOURCE GPIO_PinSource14 +#define DOWN_BUTTON_EXTI_IRQn EXTI15_10_IRQn +/** + * @brief Joystick Sel push-button + */ +#define SEL_BUTTON_PIN GPIO_Pin_12 +#define SEL_BUTTON_GPIO_PORT GPIOD +#define SEL_BUTTON_GPIO_CLK RCC_APB2Periph_GPIOD +#define SEL_BUTTON_EXTI_LINE EXTI_Line12 +#define SEL_BUTTON_EXTI_PORT_SOURCE GPIO_PortSourceGPIOD +#define SEL_BUTTON_EXTI_PIN_SOURCE GPIO_PinSource12 +#define SEL_BUTTON_EXTI_IRQn EXTI15_10_IRQn +/** + * @} + */ + +/** @addtogroup STM32100B_EVAL_LOW_LEVEL_COM + * @{ + */ +#define COMn 2 + +/** + * @brief Definition for COM port1, connected to USART1 + */ +#define EVAL_COM1 USART1 +#define EVAL_COM1_CLK RCC_APB2Periph_USART1 +#define EVAL_COM1_TX_PIN GPIO_Pin_9 +#define EVAL_COM1_TX_GPIO_PORT GPIOA +#define EVAL_COM1_TX_GPIO_CLK RCC_APB2Periph_GPIOA +#define EVAL_COM1_RX_PIN GPIO_Pin_10 +#define EVAL_COM1_RX_GPIO_PORT GPIOA +#define EVAL_COM1_RX_GPIO_CLK RCC_APB2Periph_GPIOA +#define EVAL_COM1_IRQn USART1_IRQn + +/** + * @brief Definition for COM port2, connected to USART2 (USART2 pins remapped on GPIOD) + */ +#define EVAL_COM2 USART2 +#define EVAL_COM2_CLK RCC_APB1Periph_USART2 +#define EVAL_COM2_TX_PIN GPIO_Pin_5 +#define EVAL_COM2_TX_GPIO_PORT GPIOD +#define EVAL_COM2_TX_GPIO_CLK RCC_APB2Periph_GPIOD +#define EVAL_COM2_RX_PIN GPIO_Pin_6 +#define EVAL_COM2_RX_GPIO_PORT GPIOD +#define EVAL_COM2_RX_GPIO_CLK RCC_APB2Periph_GPIOD +#define EVAL_COM2_IRQn USART2_IRQn + +/** + * @} + */ + +/** @addtogroup STM32100B_EVAL_LOW_LEVEL_SD_SPI + * @{ + */ +/** + * @brief SD SPI Interface pins + */ +#define SD_SPI SPI1 +#define SD_SPI_CLK RCC_APB2Periph_SPI1 +#define SD_SPI_SCK_PIN GPIO_Pin_5 /* PA.05 */ +#define SD_SPI_SCK_GPIO_PORT GPIOA /* GPIOA */ +#define SD_SPI_SCK_GPIO_CLK RCC_APB2Periph_GPIOA +#define SD_SPI_MISO_PIN GPIO_Pin_6 /* PA.06 */ +#define SD_SPI_MISO_GPIO_PORT GPIOA /* GPIOA */ +#define SD_SPI_MISO_GPIO_CLK RCC_APB2Periph_GPIOA +#define SD_SPI_MOSI_PIN GPIO_Pin_7 /* PA.07 */ +#define SD_SPI_MOSI_GPIO_PORT GPIOA /* GPIOA */ +#define SD_SPI_MOSI_GPIO_CLK RCC_APB2Periph_GPIOA +#define SD_CS_PIN GPIO_Pin_12 /* PC.12 */ +#define SD_CS_GPIO_PORT GPIOC /* GPIOC */ +#define SD_CS_GPIO_CLK RCC_APB2Periph_GPIOC +#define SD_DETECT_PIN GPIO_Pin_7 /* PE.07 */ +#define SD_DETECT_GPIO_PORT GPIOE /* GPIOE */ +#define SD_DETECT_GPIO_CLK RCC_APB2Periph_GPIOE + +/** + * @} + */ + +/** @addtogroup STM32100B_EVAL_LOW_LEVEL_M25P_FLASH_SPI + * @{ + */ +/** + * @brief M25P FLASH SPI Interface pins + */ +#define sFLASH_SPI SPI1 +#define sFLASH_SPI_CLK RCC_APB2Periph_SPI1 +#define sFLASH_SPI_SCK_PIN GPIO_Pin_5 /* PA.05 */ +#define sFLASH_SPI_SCK_GPIO_PORT GPIOA /* GPIOA */ +#define sFLASH_SPI_SCK_GPIO_CLK RCC_APB2Periph_GPIOA +#define sFLASH_SPI_MISO_PIN GPIO_Pin_6 /* PA.06 */ +#define sFLASH_SPI_MISO_GPIO_PORT GPIOA /* GPIOA */ +#define sFLASH_SPI_MISO_GPIO_CLK RCC_APB2Periph_GPIOA +#define sFLASH_SPI_MOSI_PIN GPIO_Pin_7 /* PA.07 */ +#define sFLASH_SPI_MOSI_GPIO_PORT GPIOA /* GPIOA */ +#define sFLASH_SPI_MOSI_GPIO_CLK RCC_APB2Periph_GPIOA +#define sFLASH_CS_PIN GPIO_Pin_9 /* PD.09 */ +#define sFLASH_CS_GPIO_PORT GPIOD /* GPIOD */ +#define sFLASH_CS_GPIO_CLK RCC_APB2Periph_GPIOD + +/** + * @} + */ + +/** @addtogroup STM32100B_EVAL_LOW_LEVEL_TSENSOR_I2C + * @{ + */ +/** + * @brief LM75 Temperature Sensor I2C Interface pins + */ +#define LM75_I2C I2C1 +#define LM75_I2C_CLK RCC_APB1Periph_I2C1 +#define LM75_I2C_SCL_PIN GPIO_Pin_6 /* PB.06 */ +#define LM75_I2C_SCL_GPIO_PORT GPIOB /* GPIOB */ +#define LM75_I2C_SCL_GPIO_CLK RCC_APB2Periph_GPIOB +#define LM75_I2C_SDA_PIN GPIO_Pin_7 /* PB.07 */ +#define LM75_I2C_SDA_GPIO_PORT GPIOB /* GPIOB */ +#define LM75_I2C_SDA_GPIO_CLK RCC_APB2Periph_GPIOB +#define LM75_I2C_SMBUSALERT_PIN GPIO_Pin_5 /* PB.05 */ +#define LM75_I2C_SMBUSALERT_GPIO_PORT GPIOB /* GPIOB */ +#define LM75_I2C_SMBUSALERT_GPIO_CLK RCC_APB2Periph_GPIOB +#define LM75_I2C_DR ((uint32_t)0x40005410) + +#define LM75_DMA_CLK RCC_AHBPeriph_DMA1 +#define LM75_DMA_TX_CHANNEL DMA1_Channel6 +#define LM75_DMA_RX_CHANNEL DMA1_Channel7 +#define LM75_DMA_TX_TCFLAG DMA1_FLAG_TC6 +#define LM75_DMA_RX_TCFLAG DMA1_FLAG_TC7 +/** + * @} + */ +/** + * @} + */ + +/** @defgroup STM32100B_EVAL_LOW_LEVEL_Exported_Macros + * @{ + */ +/** + * @} + */ + +/** @defgroup STM32100B_EVAL_LOW_LEVEL_Exported_Functions + * @{ + */ +void STM_EVAL_LEDInit(Led_TypeDef Led); +void STM_EVAL_LEDOn(Led_TypeDef Led); +void STM_EVAL_LEDOff(Led_TypeDef Led); +void STM_EVAL_LEDToggle(Led_TypeDef Led); +void STM_EVAL_PBInit(Button_TypeDef Button, ButtonMode_TypeDef Button_Mode); +uint32_t STM_EVAL_PBGetState(Button_TypeDef Button); +void STM_EVAL_COMInit(COM_TypeDef COM, USART_InitTypeDef* USART_InitStruct); +void SD_LowLevel_DeInit(void); +void SD_LowLevel_Init(void); +void sFLASH_LowLevel_DeInit(void); +void sFLASH_LowLevel_Init(void); +void LM75_LowLevel_DeInit(void); +void LM75_LowLevel_Init(void); +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32100B_EVAL_H */ +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/ diff --git a/tmp/STM32F10x_StdPeriph_Lib_V3.5.0/Utilities/STM32_EVAL/STM32100B_EVAL/stm32100b_eval_cec.c b/tmp/STM32F10x_StdPeriph_Lib_V3.5.0/Utilities/STM32_EVAL/STM32100B_EVAL/stm32100b_eval_cec.c new file mode 100644 index 0000000..3172b63 --- /dev/null +++ b/tmp/STM32F10x_StdPeriph_Lib_V3.5.0/Utilities/STM32_EVAL/STM32100B_EVAL/stm32100b_eval_cec.c @@ -0,0 +1,1722 @@ +/** + ****************************************************************************** + * @file stm32100b_eval_cec.c + * @author MCD Application Team + * @version V4.5.0 + * @date 07-March-2011 + * @brief This file provides all the STM32100B-EVAL HDMI-CEC firmware functions. + ****************************************************************************** + * @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, STMICROELECTRONICS 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. + * + * <h2><center>© COPYRIGHT 2011 STMicroelectronics</center></h2> + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32100b_eval_cec.h" + +/** @addtogroup Utilities + * @{ + */ + +/** @addtogroup STM32_EVAL + * @{ + */ + +/** @addtogroup STM32100B_EVAL + * @{ + */ + +/** @defgroup STM32100B_EVAL_CEC + * @brief This file includes the CEC Stack driver for HDMI-CEC Module + * of STM32100B-EVAL board. + * @{ + */ + +/** @defgroup STM32100B_EVAL_CEC_Private_Types + * @{ + */ + +/** + * @} + */ + +/** @defgroup STM32100B_EVAL_CEC_Private_Defines + * @{ + */ + + +/** + * @} + */ + +/** @defgroup STM32100B_EVAL_CEC_Private_Macros + * @{ + */ +/** + * @} + */ + +/** @defgroup STM32100B_EVAL_CEC_Private_Variables + * @{ + */ + +__IO uint32_t ReceivedFrame = 0; +__IO uint32_t SendFrame = 0; +__IO uint32_t BufferCount = 0, TxCounter = 0, RxCounter = 0; +__IO uint8_t BufferPointer[15]; +__IO uint32_t ReceiveStatus = 0; +__IO uint32_t SendStatus = 0; +__IO uint8_t TransErrorCode = 0; +__IO uint8_t RecepErrorCode = 0; +__IO uint8_t MyLogicalAddress = 0; +__IO uint16_t MyPhysicalAddress = 0; +__IO uint8_t DeviceType = 0; +#ifdef HDMI_CEC_USE_DDC +__IO uint8_t pBuffer[256]; +__IO uint16_t NumByteToRead = 255; +#endif +__IO uint8_t CECDevicesNumber = 0; + +HDMI_CEC_Message HDMI_CEC_TX_MessageStructPrivate; +HDMI_CEC_Message HDMI_CEC_RX_MessageStructPrivate; +HDMI_CEC_Message HDMI_CEC_TX_MessageStructure; + +__IO uint8_t FeatureOpcode = 0; +__IO uint8_t AbortReason = 0; +__IO uint8_t DeviceCount = 0; + +HDMI_CEC_Map HDMI_CEC_MapStruct; +HDMI_CEC_Map HDMI_CEC_DeviceMap[14]; + +/* CEC follower addresses */ +uint8_t* HDMI_CEC_Follower_String[13][2] = + { + {(uint8_t *)" TV ", (uint8_t *)"0"}, + {(uint8_t *)"Recording Device 1 ", (uint8_t *)"0"}, + {(uint8_t *)"Recording Device 2 ", (uint8_t *)"0"}, + {(uint8_t *)" Tuner 1 ", (uint8_t *)"0"}, + {(uint8_t *)" Playback Device 1 ", (uint8_t *)"0"}, + {(uint8_t *)" Audio System ", (uint8_t *)"0"}, + {(uint8_t *)" Tuner 2 ", (uint8_t *)"0"}, + {(uint8_t *)" Tuner 3 ", (uint8_t *)"0"}, + {(uint8_t *)" Playback Device 2 ", (uint8_t *)"0"}, + {(uint8_t *)"Recording Device 3 ", (uint8_t *)"0"}, + {(uint8_t *)" Tuner 4 ", (uint8_t *)"0"}, + {(uint8_t *)" Playback Device 3 ", (uint8_t *)"0"}, + {(uint8_t *)" Broadcast ", (uint8_t *)"1"} + }; + +/** + * @} + */ + + +/** @defgroup STM32100B_EVAL_CEC_Private_Function_Prototypes + * @{ + */ +static HDMI_CEC_Error PhysicalAddressDiscovery(void); +static HDMI_CEC_Error LogicalAddressAllocation(void); + + +/** + * @} + */ + + +/** @defgroup STM32100B_EVAL_CEC_Private_Functions + * @{ + */ + +/** + * @brief Initializes the HDMI CEC. + * @param None + * @retval HDMI_CEC_Error: CEC Error code + */ +HDMI_CEC_Error HDMI_CEC_Init(void) +{ + GPIO_InitTypeDef GPIO_InitStructure; + CEC_InitTypeDef CEC_InitStructure; + HDMI_CEC_Error errorstatus = HDMI_CEC_OK; + uint8_t sendcount = 0; + +#ifdef HDMI_CEC_USE_DDC + I2C_InitTypeDef I2C_InitStructure; + /* Enable CEC_I2C clocks */ + RCC_APB1PeriphClockCmd(HDMI_CEC_I2C_CLK, ENABLE); + + /* Enable CEC_I2C_GPIO and CEC_HPD_GPIO clocks */ + RCC_APB2PeriphClockCmd(HDMI_CEC_I2C_GPIO_CLK | HDMI_CEC_HPD_GPIO_CLK, ENABLE); +#endif + + /* Enable CEC clocks */ + RCC_APB1PeriphClockCmd(RCC_APB1Periph_CEC, ENABLE); + + /* Enable CEC_LINE_GPIO clocks */ + RCC_APB2PeriphClockCmd(HDMI_CEC_LINE_GPIO_CLK, ENABLE); + + /* Configure CEC_LINE_GPIO as Output open drain */ + GPIO_InitStructure.GPIO_Pin = HDMI_CEC_LINE_PIN; + GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD; + GPIO_Init(HDMI_CEC_LINE_GPIO_PORT, &GPIO_InitStructure); + +#ifdef HDMI_CEC_USE_DDC + /* Configure CEC_I2C_SCL_PIN and CEC_I2C_SDA_PIN as Output open drain */ + GPIO_InitStructure.GPIO_Pin = HDMI_CEC_I2C_SCL_PIN | HDMI_CEC_I2C_SDA_PIN; + GPIO_Init(HDMI_CEC_I2C_GPIO_PORT, &GPIO_InitStructure); + +/* This configuration is only when the HDMI CEC is configured as source. + The HDMI source has to provide the +5V Power signal to the sink. + On STM32100B-EVAL borad, you have to solder the SB4 Solder bridge. + Then, the source will wait for HPD signal to be asserted from the sink. + Once the HPD signal is detected the source shall read the EDID structure + throuhgh the DDC channel. */ + /* Configure CEC_HPD_GPIO as Input pull down */ + GPIO_InitStructure.GPIO_Pin = HDMI_CEC_HPD_PIN; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; + GPIO_Init(HDMI_CEC_HPD_GPIO_PORT, &GPIO_InitStructure); + + +/* This configuration is only when the HDMI CEC is configured as sink. + The HDMI sink has to wait for the +5V Power signal from the source. + On STM32100B-EVAL borad, SB4 Solder bridge should be open (default configuration). + Then, the sink will assert the HPD signal to inform the source that the EDID + is ready for read through DDC channel. In this implementation, the EDID structure + is not implemented. */ +/* GPIO_InitStructure.GPIO_Pin = HDMI_CEC_HPD_PIN; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; + GPIO_Init(HDMI_CEC_HPD_GPIO_PORT, &GPIO_InitStructure); + + HDMI_CEC_HPD_HIGH(); // Set the Hot plug detect signal */ + + /* Enable CEC_I2C */ + I2C_Cmd(HDMI_CEC_I2C, ENABLE); + + /* I2C configuration */ + I2C_InitStructure.I2C_Mode = I2C_Mode_I2C; + I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2; + I2C_InitStructure.I2C_OwnAddress1 = HDMI_CEC_I2C_SLAVE_ADDRESS7; + I2C_InitStructure.I2C_Ack = I2C_Ack_Enable; + I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit; + I2C_InitStructure.I2C_ClockSpeed = HDMI_CEC_I2C_CLOCK_SPEED; + I2C_Init(HDMI_CEC_I2C, &I2C_InitStructure); +#endif + + /* Physical Address discovery */ + errorstatus = PhysicalAddressDiscovery(); + + if (errorstatus != HDMI_CEC_OK) + { + /* Device not connected (Physical Address lost) */ + return(errorstatus); + } + + + /* CEC DeInit */ + CEC_DeInit(); + + /* Configure CEC */ + CEC_InitStructure.CEC_BitTimingMode = CEC_BitTimingStdMode; + CEC_InitStructure.CEC_BitPeriodMode = CEC_BitPeriodStdMode; + CEC_Init(&CEC_InitStructure); + + /* Set Prescaler value for APB1 clock = 24MHz */ + CEC_SetPrescaler(0x4AF); + + /* Enable CEC */ + CEC_Cmd(ENABLE); + + /* Logical Address Allocation */ + sendcount = 0; + errorstatus = LogicalAddressAllocation(); + + while ((errorstatus != HDMI_CEC_OK) && sendcount < 0x5) + { + sendcount++; + errorstatus = LogicalAddressAllocation(); + } + + if (errorstatus != HDMI_CEC_OK) + { + /* Device Unregistred */ + return(errorstatus); + } + + HDMI_CEC_CheckConnectedDevices(); + + /* Set the CEC initiator address */ + CEC_OwnAddressConfig(MyLogicalAddress); + + /* Activate CEC interrupts associated to the set of RBTF,RERR, TBTF, TERR flags */ + CEC_ITConfig(ENABLE); + + /* Report physical address*/ + errorstatus = HDMI_CEC_ReportPhysicalAddress(); + sendcount = 0; + + while ((errorstatus != HDMI_CEC_OK) && sendcount < 0x5) + { + sendcount++; + errorstatus = HDMI_CEC_ReportPhysicalAddress(); + } + + if (errorstatus != HDMI_CEC_OK) + { + /* Device Unregistred */ + return(errorstatus); + } + + return errorstatus; +} + +/** + * @brief Transmit message by taking data from typedef struct CEC_Meassage + * @param CEC_TX_MessageStructure: pointer to an CEC_Message structure that contains + * the message to be sent. + * @retval HDMI_CEC_Error: CEC Error code + */ +HDMI_CEC_Error HDMI_CEC_TransmitMessage(HDMI_CEC_Message *HDMI_CEC_TX_MessageStructure) +{ + HDMI_CEC_Error errorstatus = HDMI_CEC_OK; + __IO uint32_t count = 0, j = 0; + + SendFrame = 0; + SendStatus = 0; + TxCounter = 0; + BufferCount = 0; + + HDMI_CEC_TX_MessageStructPrivate = *HDMI_CEC_TX_MessageStructure; + + /* Initialize BufferPointer */ + for (j = 0; j < 15; j++) + { + BufferPointer[j] = 0; + } + + BufferPointer[0] = HDMI_CEC_TX_MessageStructPrivate.Opcode; + + for (BufferCount = 1; BufferCount < HDMI_CEC_TX_MessageStructPrivate.TxMessageLength + 1; BufferCount++) + { + BufferPointer[BufferCount] = HDMI_CEC_TX_MessageStructPrivate.Operande[BufferCount-1]; + } + + CEC_ClearFlag(CEC_FLAG_TBTRF | CEC_FLAG_TERR); + + /* Write single Data in the TX Buffer to Transmit through the CEC peripheral */ + CEC_SendDataByte(HDMI_CEC_TX_MessageStructPrivate.Header); + + /* Initiate Message Transmission */ + CEC_StartOfMessage(); + + while ((SendFrame == 0) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + + if (SendStatus == 0) + { + errorstatus = (HDMI_CEC_Error) TransErrorCode; + } + + return errorstatus; +} + + +/** + * @brief Get the ESR register status. + * @param None + * @retval HDMI_CEC_Error: CEC Error code + */ +HDMI_CEC_Error HDMI_CEC_GetErrorStatus (void) +{ + HDMI_CEC_Error errorstatus = HDMI_CEC_OK; + + /* Bit timing error case*/ + if (CEC_GetFlagStatus(CEC_FLAG_BTE) != RESET) + { + errorstatus = HDMI_CEC_BIT_TIMING; + } + /* Bit period error case */ + if (CEC_GetFlagStatus(CEC_FLAG_BPE) != RESET) + { + errorstatus = HDMI_CEC_BIT_PERIOD; + } + /* Recieve error case */ + if (CEC_GetFlagStatus(CEC_FLAG_RBTFE) != RESET) + { + errorstatus = HDMI_CEC_RX_BLOCK_FINISHED; + } + /* Start bit error case*/ + if (CEC_GetFlagStatus(CEC_FLAG_SBE) != RESET) + { + errorstatus = HDMI_CEC_START_BIT; + } + /* Acknowledge error case*/ + if (CEC_GetFlagStatus(CEC_FLAG_ACKE) != RESET) + { + errorstatus = HDMI_CEC_BLOCK_ACKNOWLEDGE; + } + /* Line error case */ + if (CEC_GetFlagStatus(CEC_FLAG_LINE) != RESET) + { + errorstatus = HDMI_CEC_LINE; + } + /* Transfert error case*/ + if (CEC_GetFlagStatus(CEC_FLAG_TBTFE) != RESET) + { + errorstatus = HDMI_CEC_TX_BLOCK_FINISHED; + } + /* Clear All errors */ + CEC_ClearFlag(CEC_FLAG_RERR); + CEC_ClearFlag(CEC_FLAG_TERR); + return errorstatus; +} + +/** + * @brief Allows to process all the interrupts that are high. + * @param None + * @retval None + */ +void HDMI_CEC_ProcessIRQSrc(void) +{ + /********************** Reception *********************************************/ + /* Check if a reception error occured */ + if (CEC_GetFlagStatus(CEC_FLAG_RERR)) + { + /* Set receive status bit (Error) */ + ReceiveStatus = 0; + ReceivedFrame = 1; + RecepErrorCode = HDMI_CEC_GetErrorStatus(); + CEC_ClearFlag(CEC_FLAG_RERR | CEC_FLAG_RSOM | CEC_FLAG_REOM | CEC_FLAG_RBTF); + } + else if (CEC_GetFlagStatus(CEC_FLAG_RBTF)) + { + /* Check if the byte received is the last one of the message */ + if (CEC_GetFlagStatus(CEC_FLAG_REOM)) + { + HDMI_CEC_RX_MessageStructPrivate.Operande[RxCounter-1] = CEC_ReceiveDataByte(); + HDMI_CEC_RX_MessageStructPrivate.RxMessageLength = RxCounter; + ReceiveStatus = SUCCESS; + ReceivedFrame = 1; + } + /* Check if the byte received is a Header */ + else if (CEC_GetFlagStatus(CEC_FLAG_RSOM)) + { + ReceiveStatus = 0; + HDMI_CEC_RX_MessageStructPrivate.Header = CEC_ReceiveDataByte(); + RxCounter = 0; + } + /* Receive each byte except header in the reception buffer */ + else + { + if (RxCounter != 0) + { + HDMI_CEC_RX_MessageStructPrivate.Operande[RxCounter-1] = CEC_ReceiveDataByte(); + RxCounter++; + } + else + { + HDMI_CEC_RX_MessageStructPrivate.Opcode = CEC_ReceiveDataByte(); + RxCounter++; + } + + } + /* Clear all reception flags */ + CEC_ClearFlag(CEC_FLAG_RSOM | CEC_FLAG_REOM | CEC_FLAG_RBTF); + } + + /********************** Transmission ******************************************/ + /* Check if a transmission error occured */ + if (CEC_GetFlagStatus(CEC_FLAG_TERR)) + { + TransErrorCode = HDMI_CEC_GetErrorStatus(); + CEC_ClearFlag(CEC_FLAG_TBTRF | CEC_FLAG_TERR); + SendFrame = 1; + SendStatus = 0; + } + /* Check if end of message bit is set in the data to be transmitted */ + else if (CEC_GetFlagStatus(CEC_FLAG_TEOM)) + { + CEC_ClearFlag(CEC_FLAG_TBTRF | CEC_FLAG_RBTF); + CEC_EndOfMessageCmd(DISABLE); + SendFrame = 1; + SendStatus = SUCCESS; + } + /* Check if data byte has been sent */ + else if (CEC_GetFlagStatus(CEC_FLAG_TBTRF)) + { + /* Set EOM bit if the byte to be transmitted is the last one of the TransmitBuffer */ + if (TxCounter == (HDMI_CEC_TX_MessageStructPrivate.TxMessageLength)) + { + CEC_SendDataByte(BufferPointer[TxCounter]); + TxCounter++; + CEC_ClearFlag(CEC_FLAG_TBTRF); + CEC_EndOfMessageCmd(ENABLE); + } + else + { + /* Put the byte in the TX Buffer */ + CEC_SendDataByte(BufferPointer[TxCounter]); + TxCounter++; + CEC_ClearFlag(CEC_FLAG_TBTRF); + } + } +} + +/** + * @brief Report physical address to all other devices thus allowing any + device to create a map of the network. + * @param None + * @retval HDMI_CEC_Error: CEC Error code. + */ +HDMI_CEC_Error HDMI_CEC_ReportPhysicalAddress(void) +{ + HDMI_CEC_Error errorstatus = HDMI_CEC_OK; + HDMI_CEC_Message HDMI_CEC_TX_Message; + + HDMI_CEC_TX_Message.Header = ((MyLogicalAddress << 4) | 0xF); + HDMI_CEC_TX_Message.Opcode = HDMI_CEC_OPCODE_REPORT_PHYSICAL_ADDRESS; + HDMI_CEC_TX_Message.Operande[0] = MyPhysicalAddress >> 8; + HDMI_CEC_TX_Message.Operande[1] = MyPhysicalAddress & 0xFF; + HDMI_CEC_TX_Message.Operande[2] = DeviceType; + HDMI_CEC_TX_Message.TxMessageLength = 0x03; + + errorstatus = HDMI_CEC_TransmitMessage(&HDMI_CEC_TX_Message); + + return errorstatus; +} + +/** + * @brief Handle CEC command receive callback. + * When receiving the STANDBY Opcode commande, the system is entred in + * Stop mode and when wakeup, the PLL is configured as system clock and + * the HSI is selected as PLL source. + * @param None + * @retval None + */ +void HDMI_CEC_CommandCallBack(void) +{ + uint8_t i = 0, sendcount = 0; + HDMI_CEC_Error errorstatus = HDMI_CEC_OK; + EXTI_InitTypeDef EXTI_InitStructure; + + switch (HDMI_CEC_RX_MessageStructPrivate.Opcode) + { + case HDMI_CEC_OPCODE_REPORT_PHYSICAL_ADDRESS: + HDMI_CEC_MapStruct.PhysicalAddress_A = HDMI_CEC_RX_MessageStructPrivate.Operande[1] >> 4; + HDMI_CEC_MapStruct.PhysicalAddress_B = HDMI_CEC_RX_MessageStructPrivate.Operande[1] & 0x0F; + HDMI_CEC_MapStruct.PhysicalAddress_C = HDMI_CEC_RX_MessageStructPrivate.Operande[0] >> 4; + HDMI_CEC_MapStruct.PhysicalAddress_D = HDMI_CEC_RX_MessageStructPrivate.Operande[0] & 0x0F; + HDMI_CEC_MapStruct.LogicalAddress = (HDMI_CEC_RX_MessageStructPrivate.Header >> 0x4) & 0x0F; + HDMI_CEC_MapStruct.DeviceType = HDMI_CEC_RX_MessageStructPrivate.Operande[2]; + HDMI_CEC_DeviceMap[DeviceCount] = HDMI_CEC_MapStruct; + HDMI_CEC_Follower_String[(HDMI_CEC_DeviceMap[DeviceCount].LogicalAddress)][1] = (uint8_t *)"1"; + DeviceCount++; + break; + + case HDMI_CEC_OPCODE_STANDBY: + /* CEC Line */ + GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource8); + /* Configure the CEC Line as EXTI Line on Falling Edge */ + EXTI_ClearITPendingBit(EXTI_Line8); + EXTI_InitStructure.EXTI_Line = EXTI_Line8; + EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt; + EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; + EXTI_InitStructure.EXTI_LineCmd = ENABLE; + EXTI_Init(&EXTI_InitStructure); + /* Request to enter Stop mode */ + PWR_EnterSTOPMode(PWR_Regulator_ON, PWR_STOPEntry_WFI); + + /* Disable the CEC EXTI Line */ + EXTI_InitStructure.EXTI_LineCmd = DISABLE; + EXTI_Init(&EXTI_InitStructure); + /* Configure the PLL Source */ + RCC_PLLConfig(RCC_PLLSource_HSI_Div2, RCC_PLLMul_6); + + /* Enable PLL */ + RCC_PLLCmd(ENABLE); + + /* Wait till PLL is ready */ + while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET) + { + } + + /* Select PLL as system clock source */ + RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK); + + /* Wait till PLL is used as system clock source */ + while(RCC_GetSYSCLKSource() != 0x08) + { + } + break; + + case HDMI_CEC_OPCODE_GET_CEC_VERSION: + /* Send the Used CEC version */ + HDMI_CEC_TX_MessageStructPrivate.Header = ((MyLogicalAddress << 4) | HDMI_CEC_RX_MessageStructPrivate.Header >> 4); + HDMI_CEC_TX_MessageStructPrivate.Opcode = HDMI_CEC_OPCODE_CEC_VERSION; + HDMI_CEC_TX_MessageStructPrivate.Operande[0] = HDMI_CEC_VERSION; /* CEC Version */ + HDMI_CEC_TX_MessageStructPrivate.TxMessageLength = 0x01; + errorstatus = HDMI_CEC_TransmitMessage(&HDMI_CEC_TX_MessageStructPrivate); + + /* Retransmit message until 5 time */ + while ((errorstatus != HDMI_CEC_OK) && sendcount < 0x5) + { + sendcount++; + errorstatus = HDMI_CEC_TransmitMessage(&HDMI_CEC_TX_MessageStructPrivate); + } + break; + + case HDMI_CEC_OPCODE_GIVE_PHYSICAL_ADDRESS: + /* Send the Physical address */ + errorstatus = HDMI_CEC_ReportPhysicalAddress(); + sendcount = 0; + /* Retransmit message until 5 time */ + while ((errorstatus != HDMI_CEC_OK) && sendcount < 0x5) + { + sendcount++; + errorstatus = HDMI_CEC_ReportPhysicalAddress(); + } + break; + + case HDMI_CEC_OPCODE_FEATURE_ABORT: + /* The device doesn't support the requested message type, or that it cannot + execute it at the present time. */ + FeatureOpcode = HDMI_CEC_RX_MessageStructPrivate.Operande[0]; + AbortReason = HDMI_CEC_RX_MessageStructPrivate.Operande[1]; + break; + + case HDMI_CEC_OPCODE_GIVE_OSD_NAME: + /* Send the OSD name = STM32100B CEC*/ + HDMI_CEC_TX_MessageStructPrivate.Header = ((MyLogicalAddress << 4) | HDMI_CEC_RX_MessageStructPrivate.Header >> 4); + HDMI_CEC_TX_MessageStructPrivate.Opcode = HDMI_CEC_OPCODE_SET_OSD_NAME; + /* STM32100B*/ + HDMI_CEC_TX_MessageStructPrivate.Operande[0] = 0x53; + HDMI_CEC_TX_MessageStructPrivate.Operande[1] = 0x54; + HDMI_CEC_TX_MessageStructPrivate.Operande[2] = 0x4D; + HDMI_CEC_TX_MessageStructPrivate.Operande[3] = 0x33; + HDMI_CEC_TX_MessageStructPrivate.Operande[4] = 0x32; + HDMI_CEC_TX_MessageStructPrivate.Operande[5] = 0x31; + HDMI_CEC_TX_MessageStructPrivate.Operande[6] = 0x30; + HDMI_CEC_TX_MessageStructPrivate.Operande[7] = 0x30; + HDMI_CEC_TX_MessageStructPrivate.Operande[8] = 0x42; + HDMI_CEC_TX_MessageStructPrivate.Operande[9] = 0x20; + /* CEC */ + HDMI_CEC_TX_MessageStructPrivate.Operande[10] = 0x43; + HDMI_CEC_TX_MessageStructPrivate.Operande[11] = 0x45; + HDMI_CEC_TX_MessageStructPrivate.Operande[12] = 0x43; + HDMI_CEC_TX_MessageStructPrivate.TxMessageLength = 13; + errorstatus = HDMI_CEC_TransmitMessage(&HDMI_CEC_TX_MessageStructPrivate); + sendcount = 0; + /* Retransmit message until 5 time */ + while ((errorstatus != HDMI_CEC_OK) && sendcount < 0x5) + { + sendcount++; + errorstatus = HDMI_CEC_TransmitMessage(&HDMI_CEC_TX_MessageStructPrivate); + } + break; + + case HDMI_CEC_OPCODE_ROUTING_CHANGE: + for (i = 0;i < 0x14;i++) + { + if ((HDMI_CEC_DeviceMap[i].PhysicalAddress_A == HDMI_CEC_RX_MessageStructPrivate.Operande[1] >> 4) && + (HDMI_CEC_DeviceMap[i].PhysicalAddress_B == HDMI_CEC_RX_MessageStructPrivate.Operande[1]&0x0F) && + (HDMI_CEC_DeviceMap[i].PhysicalAddress_C == HDMI_CEC_RX_MessageStructPrivate.Operande[0] >> 4) && + (HDMI_CEC_DeviceMap[i].PhysicalAddress_D == HDMI_CEC_RX_MessageStructPrivate.Operande[0]&0x0F)) + { + HDMI_CEC_MapStruct.LogicalAddress = (HDMI_CEC_RX_MessageStructPrivate.Header >> 0x4) & 0x0F; + HDMI_CEC_MapStruct.DeviceType = HDMI_CEC_RX_MessageStructPrivate.Operande[2]; + HDMI_CEC_DeviceMap[i] = HDMI_CEC_MapStruct; + } + } + break; + + default: + /* Send Abort feature*/ + HDMI_CEC_TX_MessageStructPrivate.Header = ((MyLogicalAddress << 4) | HDMI_CEC_RX_MessageStructPrivate.Header >> 4); + HDMI_CEC_TX_MessageStructPrivate.Opcode = HDMI_CEC_OPCODE_FEATURE_ABORT; + HDMI_CEC_TX_MessageStructPrivate.Operande[0] = 0x02; /* defines command to be performed */ + HDMI_CEC_TX_MessageStructPrivate.Operande[1] = HDMI_CEC_REFUSED; /* Reason for abort feature */ + HDMI_CEC_TX_MessageStructPrivate.TxMessageLength = 0x02; + errorstatus = HDMI_CEC_TransmitMessage(&HDMI_CEC_TX_MessageStructPrivate); + sendcount = 0; + /* Retransmit message until 5 time */ + while ((errorstatus != HDMI_CEC_OK) && sendcount < 0x5) + { + sendcount++; + errorstatus = HDMI_CEC_TransmitMessage(&HDMI_CEC_TX_MessageStructPrivate); + } + break; + + } +} + +/** + * @brief Check the connected CEC devices. + * @param None + * @retval HDMI_CEC_Error + */ +HDMI_CEC_Error HDMI_CEC_CheckConnectedDevices(void) +{ + HDMI_CEC_Error errorstatus = HDMI_CEC_OK; + uint32_t count = 0, i = 1; + + /*----------------------------- TV device ---------------------------*/ + CEC_OwnAddressConfig(MyLogicalAddress); /* Own address = MyLogicalAddress */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte((MyLogicalAddress << 4) | 0x0); + + /* Start of message */ + CEC_StartOfMessage(); + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_OK) + { + HDMI_CEC_Follower_String[0][1] = (uint8_t *)"1"; + i++; + errorstatus = HDMI_CEC_OK; + } + + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF); + CEC_EndOfMessageCmd(DISABLE); + + /*----------------------------- Recording device 1 ---------------------------*/ + CEC_OwnAddressConfig(MyLogicalAddress); /* Own address = MyLogicalAddress */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte((MyLogicalAddress << 4) | 0x1); + + /* Start of message */ + CEC_StartOfMessage(); + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_OK) + { + HDMI_CEC_Follower_String[1][1] = (uint8_t *)"1"; + i++; + errorstatus = HDMI_CEC_OK; + } + + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF); + CEC_EndOfMessageCmd(DISABLE); + /*----------------------------- Recording device 2 ---------------------------*/ + CEC_OwnAddressConfig(MyLogicalAddress); /* Own address = MyLogicalAddress */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte((MyLogicalAddress << 4) | 0x2); + + /* Start of message */ + CEC_StartOfMessage(); + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_OK) + { + HDMI_CEC_Follower_String[2][1] = (uint8_t *)"1"; + i++; + errorstatus = HDMI_CEC_OK; + } + + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF); + CEC_EndOfMessageCmd(DISABLE); + + /*----------------------------- Tuner 1 ---------------------------*/ + CEC_OwnAddressConfig(MyLogicalAddress); /* Own address = MyLogicalAddress */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte((MyLogicalAddress << 4) | 0x3); + + /* Start of message */ + CEC_StartOfMessage(); + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_OK) + { + HDMI_CEC_Follower_String[3][1] = (uint8_t *)"1"; + i++; + errorstatus = HDMI_CEC_OK; + } + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF); + CEC_EndOfMessageCmd(DISABLE); + /*----------------------------- Playback device 1 ---------------------------*/ + CEC_OwnAddressConfig(MyLogicalAddress); /* Own address = MyLogicalAddress */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte((MyLogicalAddress << 4) | 0x4); + + /* Start of message */ + CEC_StartOfMessage(); + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_OK) + { + HDMI_CEC_Follower_String[4][1] = (uint8_t *)"1"; + i++; + errorstatus = HDMI_CEC_OK; + } + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF); + CEC_EndOfMessageCmd(DISABLE); + + /*----------------------------- Audio system ---------------------------*/ + CEC_OwnAddressConfig(MyLogicalAddress); /* Own address = MyLogicalAddress */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte((MyLogicalAddress << 4) | 0x5); + + /* Start of message */ + CEC_StartOfMessage(); + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_OK) + { + HDMI_CEC_Follower_String[5][1] = (uint8_t *)"1"; + i++; + errorstatus = HDMI_CEC_OK; + } + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF); + CEC_EndOfMessageCmd(DISABLE); + + /*----------------------------- Tuner 2 ---------------------------*/ + CEC_OwnAddressConfig(MyLogicalAddress); /* Own address = MyLogicalAddress */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte((MyLogicalAddress << 4) | 0x6); + + /* Start of message */ + CEC_StartOfMessage(); + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_OK) + { + HDMI_CEC_Follower_String[6][1] = (uint8_t *)"1"; + i++; + errorstatus = HDMI_CEC_OK; + } + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF); + CEC_EndOfMessageCmd(DISABLE); + + /*----------------------------- Tuner 3 ---------------------------*/ + CEC_OwnAddressConfig(MyLogicalAddress); /* Own address = MyLogicalAddress */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte((MyLogicalAddress << 4) | 0x7); + + /* Start of message */ + CEC_StartOfMessage(); + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_OK) + { + HDMI_CEC_Follower_String[7][1] = (uint8_t *)"1"; + i++; + errorstatus = HDMI_CEC_OK; + } + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF); + CEC_EndOfMessageCmd(DISABLE); + + /*----------------------------- Playback device 2 ---------------------------*/ + CEC_OwnAddressConfig(MyLogicalAddress); /* Own address = MyLogicalAddress */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte((MyLogicalAddress << 4) | 0x8); + + /* Start of message */ + CEC_StartOfMessage(); + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_OK) + { + HDMI_CEC_Follower_String[8][1] = (uint8_t *)"1"; + i++; + errorstatus = HDMI_CEC_OK; + } + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF); + CEC_EndOfMessageCmd(DISABLE); + + /*----------------------------- Recording device 3 ---------------------------*/ + CEC_OwnAddressConfig(MyLogicalAddress); /* Own address = MyLogicalAddress */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte((MyLogicalAddress << 4) | 0x9); + + /* Start of message */ + CEC_StartOfMessage(); + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_OK) + { + HDMI_CEC_Follower_String[9][1] = (uint8_t *)"1"; + i++; + errorstatus = HDMI_CEC_OK; + } + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF); + CEC_EndOfMessageCmd(DISABLE); + /*----------------------------- Tuner 4 ---------------------------*/ + CEC_OwnAddressConfig(MyLogicalAddress); /* Own address = MyLogicalAddress */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte((MyLogicalAddress << 4) | 0xA); + + /* Start of message */ + CEC_StartOfMessage(); + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_OK) + { + HDMI_CEC_Follower_String[10][1] = (uint8_t *)"1"; + i++; + errorstatus = HDMI_CEC_OK; + } + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF); + CEC_EndOfMessageCmd(DISABLE); + /*----------------------------- Playback device 3 ---------------------------*/ + CEC_OwnAddressConfig(MyLogicalAddress); /* Own address = MyLogicalAddress */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte((MyLogicalAddress << 4) | 0xB); + + /* Start of message */ + CEC_StartOfMessage(); + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_OK) + { + HDMI_CEC_Follower_String[11][1] = (uint8_t *)"1"; + i++; + errorstatus = HDMI_CEC_OK; + } + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF); + CEC_EndOfMessageCmd(DISABLE); + + CECDevicesNumber = i - 1; + + return errorstatus; +} + +/** + * @brief Physical address discovery. + * @param None + * @retval HDMI_CEC_Error: CEC Error code. + */ +static HDMI_CEC_Error PhysicalAddressDiscovery(void) +{ + HDMI_CEC_Error errorstatus = HDMI_CEC_OK; +#ifdef HDMI_CEC_USE_DDC + uint32_t index = 0, i = 0; +#endif + + /*------------------------------ Physical address discovery -----------------*/ + if (HDMI_CEC_ROOT == 0x1) + { + MyPhysicalAddress = 0x0000; + /* The HDMI-CEC here is configured as sink or as a repeater. The configuration + of the +5V power signal and the HPD should be well configured. + Implement here the EDID Structure to be sent to the HDMI source. + For more details please refer to the HDMI specification. + The EDID structure should be sent to the device source using the DDC Channel + and using the HPD signal. */ + } + else + { + +#ifdef HDMI_CEC_USE_DDC + /* The HDMI-CEC here is configured as source or as a repeater. The configuration + of the +5V power signal and the HPD should be well configured. + The source should wait for HPD and then read the EDID structure. */ + while(GPIO_ReadInputDataBit(HDMI_CEC_HPD_GPIO_PORT, HDMI_CEC_HPD_PIN) == RESET) + { + } + /* Wait for 100 ms after HPD was received */ + for(i = 0; i < 0x5FFFF; i++) + { + } + + /* Return the physical address using the I2C by reading the 2 bytes 24 and + 25 form the EDID */ + /* Read the EDID Block 0 and EDID Block 1 at address 0xA0 */ + /*!< While the bus is busy */ + while(I2C_GetFlagStatus(HDMI_CEC_I2C, I2C_FLAG_BUSY)) + { + } + + /*!< Send START condition */ + I2C_GenerateSTART(HDMI_CEC_I2C, ENABLE); + + /*!< Test on EV5 and clear it */ + while(!I2C_CheckEvent(HDMI_CEC_I2C, I2C_EVENT_MASTER_MODE_SELECT)) + { + } + + /*!< Send EEPROM address for write */ + I2C_Send7bitAddress(HDMI_CEC_I2C, 0xA0, I2C_Direction_Transmitter); + + + /*!< Test on EV6 and clear it */ + while(!I2C_CheckEvent(HDMI_CEC_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) + { + } + + /*!< Send the EEPROM's internal address to read from: Only one byte address */ + I2C_SendData(HDMI_CEC_I2C, 0x00); + + /*!< Test on EV8 and clear it */ + while(!I2C_CheckEvent(HDMI_CEC_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) + { + } + + /*!< Send STRAT condition a second time */ + I2C_GenerateSTART(HDMI_CEC_I2C, ENABLE); + + /*!< Test on EV5 and clear it */ + while(!I2C_CheckEvent(HDMI_CEC_I2C, I2C_EVENT_MASTER_MODE_SELECT)) + { + } + + /*!< Send EEPROM address for read */ + I2C_Send7bitAddress(HDMI_CEC_I2C, 0xA1, I2C_Direction_Receiver); + + /*!< Test on EV6 and clear it */ + while(!I2C_CheckEvent(HDMI_CEC_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED)) + { + } + + /* While there is data to be read */ + while (NumByteToRead-- > 1) + { + while(I2C_CheckEvent(HDMI_CEC_I2C, I2C_EVENT_MASTER_BYTE_RECEIVED)) + { + } + for(i = 0; i < 0xFFF; i++) + { + } + pBuffer[index++] = I2C_ReceiveData(HDMI_CEC_I2C); + } + + /* Disable Acknowledgement */ + I2C_AcknowledgeConfig(HDMI_CEC_I2C, DISABLE); + + /* Send STOP Condition */ + I2C_GenerateSTOP(HDMI_CEC_I2C, ENABLE); + + while(I2C_CheckEvent(HDMI_CEC_I2C, I2C_EVENT_MASTER_BYTE_RECEIVED)); + pBuffer[index] = I2C_ReceiveData(HDMI_CEC_I2C); + + /* Enable Acknowledgement to be ready for another reception */ + I2C_AcknowledgeConfig(HDMI_CEC_I2C, ENABLE); + MyPhysicalAddress = ((pBuffer[138] << 8) | pBuffer[137]); +#else + MyPhysicalAddress = 0x1000; +#endif + } + + return errorstatus; +} +/** + * @brief Allocate the logical address. + * @param None + * @retval HDMI_CEC_Error: CEC Error code. + */ +static HDMI_CEC_Error LogicalAddressAllocation(void) +{ + HDMI_CEC_Error errorstatus = HDMI_CEC_OK; + uint32_t count = 0; + + /*------------------ Logical address allocation -----------------------------*/ + /* Get the device type */ + /* Device type = CEC_TV */ + if (DeviceType == HDMI_CEC_TV) + { + if (HDMI_CEC_ROOT) + { + MyLogicalAddress = 0x00; + } + else + { + CEC_OwnAddressConfig(0xE); /* Own address = 0xE */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte(0xEE); + + /* Start of message */ + CEC_StartOfMessage(); + + /* Wait till the polling message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_BLOCK_ACKNOWLEDGE) + { + MyLogicalAddress = 0x0E; + errorstatus = HDMI_CEC_OK; + } + else if (errorstatus == HDMI_CEC_OK) + { + MyLogicalAddress = 0x0F; + errorstatus = HDMI_CEC_DEVICE_UNREGISTRED; + } + } + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF); + CEC_EndOfMessageCmd(DISABLE); + } + + /* Device type = CEC_RECORDING */ + if (DeviceType == HDMI_CEC_RECORDING) + { + CEC_OwnAddressConfig(0x1); /* Own address = 0x1 */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte(0x11); + + /* Start of message */ + CEC_StartOfMessage(); + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_BLOCK_ACKNOWLEDGE) + { + MyLogicalAddress = 0x01; + errorstatus = HDMI_CEC_OK; + } + else if (errorstatus == HDMI_CEC_OK) + { + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF | CEC_FLAG_TERR); + + CEC_EndOfMessageCmd(DISABLE); + + CEC_OwnAddressConfig(0x2); /* Own address = 0x2 */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte(0x22); + + /* Start of message */ + CEC_StartOfMessage(); + + count = 0; + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_BLOCK_ACKNOWLEDGE) + { + MyLogicalAddress = 0x02; + errorstatus = HDMI_CEC_OK; + } + else if (errorstatus == HDMI_CEC_OK) + { + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF | CEC_FLAG_TERR); + + CEC_EndOfMessageCmd(DISABLE); + + CEC_OwnAddressConfig(0x9); /* Own address = 0x9 */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte(0x99); + + /* Start of message */ + CEC_StartOfMessage(); + + count = 0; + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_BLOCK_ACKNOWLEDGE) + { + MyLogicalAddress = 0x09; + errorstatus = HDMI_CEC_OK; + } + else if (errorstatus == HDMI_CEC_OK) + { + MyLogicalAddress = 0x0F; + errorstatus = HDMI_CEC_DEVICE_UNREGISTRED; + } + } + } + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF | CEC_FLAG_TERR); + CEC_EndOfMessageCmd(DISABLE); + } + + /* Device type = CEC_TUNER */ + if (DeviceType == HDMI_CEC_TUNER) + { + CEC_OwnAddressConfig(0x3); /* Own address = 0x3 */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte(0x33); + + /* Start of message */ + CEC_StartOfMessage(); + + count = 0; + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_BLOCK_ACKNOWLEDGE) + { + MyLogicalAddress = 0x03; + errorstatus = HDMI_CEC_OK; + } + else if (errorstatus == HDMI_CEC_OK) + { + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF | CEC_FLAG_TERR); + + CEC_EndOfMessageCmd(DISABLE); + + CEC_OwnAddressConfig(0x6); /* Own address = 0x6 */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte(0x66); + + /* Start of message */ + CEC_StartOfMessage(); + + count = 0; + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_BLOCK_ACKNOWLEDGE) + { + MyLogicalAddress = 0x06; + errorstatus = HDMI_CEC_OK; + } + else if (errorstatus == HDMI_CEC_OK) + { + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF | CEC_FLAG_TERR); + + CEC_EndOfMessageCmd(DISABLE); + + CEC_OwnAddressConfig(0x7); /* Own address = 0x7 */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte(0x77); + + /* Start of message */ + CEC_StartOfMessage(); + + count = 0; + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_BLOCK_ACKNOWLEDGE) + { + MyLogicalAddress = 0x07; + errorstatus = HDMI_CEC_OK; + } + else if (errorstatus == HDMI_CEC_OK) + { + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF | CEC_FLAG_TERR); + + CEC_EndOfMessageCmd(DISABLE); + + CEC_OwnAddressConfig(0xA); /* Own address = 0xA */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte(0xAA); + + /* Start of message */ + CEC_StartOfMessage(); + + count = 0; + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_BLOCK_ACKNOWLEDGE) + { + MyLogicalAddress = 0x0A; + errorstatus = HDMI_CEC_OK; + } + else if (errorstatus == HDMI_CEC_OK) + { + MyLogicalAddress = 0x0F; + errorstatus = HDMI_CEC_DEVICE_UNREGISTRED; + } + } + } + } + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF | CEC_FLAG_TERR); + CEC_EndOfMessageCmd(DISABLE); + } + + /* Device type = CEC_PLAYBACK */ + if (DeviceType == HDMI_CEC_PLAYBACK) + { + CEC_OwnAddressConfig(0x4); /* Own address = 0x4 */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte(0x44); + + /* Start of message */ + CEC_StartOfMessage(); + + count = 0; + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_BLOCK_ACKNOWLEDGE) + { + MyLogicalAddress = 0x04; + errorstatus = HDMI_CEC_OK; + } + else if (errorstatus == HDMI_CEC_OK) + { + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF | CEC_FLAG_TERR); + + CEC_EndOfMessageCmd(DISABLE); + + CEC_OwnAddressConfig(0x8); /* Own address = 0x8 */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte(0x88); + + /* Start of message */ + CEC_StartOfMessage(); + + count = 0; + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_BLOCK_ACKNOWLEDGE) + { + MyLogicalAddress = 0x08; + errorstatus = HDMI_CEC_OK; + } + else if (errorstatus == HDMI_CEC_OK) + { + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF | CEC_FLAG_TERR); + + CEC_EndOfMessageCmd(DISABLE); + + CEC_OwnAddressConfig(0xB); /* Own address = 0xBB */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte(0xBB); + + /* Start of message */ + CEC_StartOfMessage(); + + count = 0; + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_BLOCK_ACKNOWLEDGE) + { + MyLogicalAddress = 0x0B; + errorstatus = HDMI_CEC_OK; + } + else if (errorstatus == HDMI_CEC_OK) + { + MyLogicalAddress = 0x0F; + errorstatus = HDMI_CEC_DEVICE_UNREGISTRED; + } + } + } + + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF | CEC_FLAG_TERR); + CEC_EndOfMessageCmd(DISABLE); + } + + /* Device type = CEC Audio System */ + if (DeviceType == HDMI_CEC_AUDIOSYSTEM) + { + CEC_OwnAddressConfig(0x5); /* Own address = 0x5 */ + + CEC_EndOfMessageCmd(ENABLE); + + CEC_SendDataByte(0x55); + + /* Start of message */ + CEC_StartOfMessage(); + + count = 0; + + /* Wait till the header message is sent */ + while ((CEC_GetFlagStatus(CEC_FLAG_TBTRF) == RESET) && (CEC_GetFlagStatus(CEC_FLAG_TERR) == RESET) && (count < HDMI_CEC_TIMEOUT_VALUE)) + { + count++; + } + + if (count >= HDMI_CEC_TIMEOUT_VALUE) + { + errorstatus = HDMI_CEC_TIMEOUT; + return(errorstatus); + } + + errorstatus = HDMI_CEC_GetErrorStatus(); + + if (errorstatus == HDMI_CEC_BLOCK_ACKNOWLEDGE) + { + MyLogicalAddress = 0x05; + errorstatus = HDMI_CEC_OK; + } + else if (errorstatus == HDMI_CEC_OK) + { + MyLogicalAddress = 0x0F; + errorstatus = HDMI_CEC_DEVICE_UNREGISTRED; + } + + /* Clear CEC CSR register */ + CEC_ClearFlag(CEC_FLAG_TBTRF | CEC_FLAG_TERR); + CEC_EndOfMessageCmd(DISABLE); + } + + return errorstatus; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/ + + diff --git a/tmp/STM32F10x_StdPeriph_Lib_V3.5.0/Utilities/STM32_EVAL/STM32100B_EVAL/stm32100b_eval_cec.h b/tmp/STM32F10x_StdPeriph_Lib_V3.5.0/Utilities/STM32_EVAL/STM32100B_EVAL/stm32100b_eval_cec.h new file mode 100644 index 0000000..4bec71a --- /dev/null +++ b/tmp/STM32F10x_StdPeriph_Lib_V3.5.0/Utilities/STM32_EVAL/STM32100B_EVAL/stm32100b_eval_cec.h @@ -0,0 +1,290 @@ +/** + ****************************************************************************** + * @file stm32100b_eval_cec.h + * @author MCD Application Team + * @version V4.5.0 + * @date 07-March-2011 + * @brief This file contains all the functions prototypes for the stm32100b_eval_cec + * firmware 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, STMICROELECTRONICS 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. + * + * <h2><center>© COPYRIGHT 2011 STMicroelectronics</center></h2> + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32100B_EVAL_CEC_H +#define __STM32100B_EVAL_CEC_H + +#ifdef __cplusplus +extern "C" +{ +#endif + + /* Includes ------------------------------------------------------------------*/ +#include "stm32f10x.h" + +/** @addtogroup Utilities + * @{ + */ + +/** @addtogroup STM32_EVAL + * @{ + */ + +/** @addtogroup STM32100B_EVAL + * @{ + */ + +/** @defgroup STM32100B_EVAL_CEC + * @{ + */ + +/** @defgroup STM32100B_EVAL_CEC_Exported_Types + * @{ + */ +typedef enum +{ + HDMI_CEC_BIT_TIMING = (1), /*!< CEC Bit Timing Error */ + HDMI_CEC_BIT_PERIOD = (2), /*!< CEC Bit Period Error */ + HDMI_CEC_RX_BLOCK_FINISHED = (3), /*!< CEC Receive Block finished Error */ + HDMI_CEC_START_BIT = (4), /*!< CEC Start Bit Error */ + HDMI_CEC_BLOCK_ACKNOWLEDGE = (5), /*!< CEC Block Acknowledge Error */ + HDMI_CEC_LINE = (6), /*!< CEC Line Error */ + HDMI_CEC_TX_BLOCK_FINISHED = (7), /*!< CEC Transmit Block Transfer finished Error */ + HDMI_CEC_DEVICE_UNREGISTRED = (8), /*!< CEC Device Unregistred */ + HDMI_CEC_TIMEOUT = (9), /*!< CEC TimeOut */ + HDMI_CEC_OK = (10) /*!< CEC OK */ +}HDMI_CEC_Error; + +typedef struct +{ + __IO uint8_t PhysicalAddress_A; + __IO uint8_t PhysicalAddress_B; + __IO uint8_t PhysicalAddress_C; + __IO uint8_t PhysicalAddress_D; + __IO uint8_t LogicalAddress; + __IO uint8_t DeviceType; +}HDMI_CEC_Map; + + +#define HDMI_CEC_TX_MESSAGE_LENGTH_MAX ((uint32_t)0x0000000E) +#define HDMI_CEC_TIMEOUT_VALUE ((uint32_t)0x001FFFFF) + +/** +* @brief CEC Init Structure definition +*/ +typedef struct +{ + __IO uint8_t Header; + __IO uint8_t Opcode; + __IO uint8_t Operande[HDMI_CEC_TX_MESSAGE_LENGTH_MAX]; + __IO uint8_t TxMessageLength; + __IO uint8_t RxMessageLength; +}HDMI_CEC_Message; + +/** +* @} +*/ + +/** @defgroup STM32100B_EVAL_CEC_Exported_Constants + * @{ + */ + +/** + * @brief CEC device types + */ +#define HDMI_CEC_TV 0x00 +#define HDMI_CEC_RECORDING 0x01 +#define HDMI_CEC_TUNER 0x03 +#define HDMI_CEC_PLAYBACK 0x04 +#define HDMI_CEC_AUDIOSYSTEM 0x05 + + +/** + * @brief HDMI CEC I2C Interface pins + */ +#define HDMI_CEC_I2C_SCL_PIN GPIO_Pin_10 +#define HDMI_CEC_I2C_SDA_PIN GPIO_Pin_11 +#define HDMI_CEC_I2C_GPIO_PORT GPIOB +#define HDMI_CEC_I2C_GPIO_CLK RCC_APB2Periph_GPIOB +#define HDMI_CEC_I2C I2C2 +#define HDMI_CEC_I2C_CLK RCC_APB1Periph_I2C2 + +/** + * @brief HDMI CEC HPD (Hot Plug Detect) Interface pin + */ +#define HDMI_CEC_HPD_PIN GPIO_Pin_12 +#define HDMI_CEC_HPD_GPIO_PORT GPIOB +#define HDMI_CEC_HPD_GPIO_CLK RCC_APB2Periph_GPIOB + +/** + * @brief HDMI CEC Interface pin + */ +#define HDMI_CEC_LINE_PIN GPIO_Pin_8 +#define HDMI_CEC_LINE_GPIO_PORT GPIOB +#define HDMI_CEC_LINE_GPIO_CLK RCC_APB2Periph_GPIOB + +#define HDMI_CEC_I2C_SLAVE_ADDRESS7 0xA0 +#define HDMI_CEC_I2C_CLOCK_SPEED 100000 + +/** + * @brief HDMI CEC Root (Mainly for TV with a fixed physical address (0.0.0.0)) + * If you want to configure the STM32100B-EVAL board as CEC Root (Sink) + * change the following define to 0x1 + */ +#define HDMI_CEC_ROOT 0x00 + +/** + * @brief To select if the DDC Channel will be used for physical address discovery + * or not. To use the DDC Channel to read the EDID structure uncomment + * the following line. + * If the device is configured as HMDI source it should read his own physical + * address from the sink that is connected to. + */ +/* #define HDMI_CEC_USE_DDC */ + +/** + * @brief CEC version: V1.3a + */ +#define HDMI_CEC_VERSION 0x04 + +/** + * @brief Reason for Abort feature + */ +#define HDMI_CEC_UNRECOGNIZED_OPCODE 0x00 +#define HDMI_CEC_NOT_CORRECT_MODETORESPOND 0x01 +#define HDMI_CEC_CANNOTPROVIDE_SOURCE 0x02 +#define HDMI_CEC_INVALID_OPERAND 0x03 +#define HDMI_CEC_REFUSED 0x04 + +/** + * @brief HDMI CEC specific commands + */ +#define HDMI_CEC_OPCODE_ACTIVE_SOURCE ((uint8_t) 0x82) +#define HDMI_CEC_OPCODE_IMAGE_VIEW_ON ((uint8_t) 0x04) +#define HDMI_CEC_OPCODE_TEXT_VIEW_ON ((uint8_t) 0x0D) +#define HDMI_CEC_OPCODE_INACTIVE_SOURCE ((uint8_t) 0x9D) +#define HDMI_CEC_OPCODE_REQUEST_ACTIVE_SOURCE ((uint8_t) 0x85) +#define HDMI_CEC_OPCODE_ROUTING_CHANGE ((uint8_t) 0x80) +#define HDMI_CEC_OPCODE_ROUTING_INFORMATION ((uint8_t) 0x81) +#define HDMI_CEC_OPCODE_SET_STREAM_PATH ((uint8_t) 0x86) +#define HDMI_CEC_OPCODE_STANDBY ((uint8_t) 0x36) +#define HDMI_CEC_OPCODE_RECORD_OFF ((uint8_t) 0x0B) +#define HDMI_CEC_OPCODE_RECORD_ON ((uint8_t) 0x09) +#define HDMI_CEC_OPCODE_RECORD_STATUS ((uint8_t) 0x0A) +#define HDMI_CEC_OPCODE_RECORD_TV_SCREEN ((uint8_t) 0x0F) +#define HDMI_CEC_OPCODE_CLEAR_ANALOGUE_TIMER ((uint8_t) 0x33) +#define HDMI_CEC_OPCODE_CLEAR_DIGITAL_TIMER ((uint8_t) 0x99) +#define HDMI_CEC_OPCODE_CLEAR_EXTERNAL_TIMER ((uint8_t) 0xA1) +#define HDMI_CEC_OPCODE_SET_ANALOGUE_TIMER ((uint8_t) 0x34) +#define HDMI_CEC_OPCODE_SET_DIGITAL_TIMER ((uint8_t) 0x97) +#define HDMI_CEC_OPCODE_SET_EXTERNAL_TIMER ((uint8_t) 0xA2) +#define HDMI_CEC_OPCODE_SET_TIMER_PROGRAM_TITLE ((uint8_t) 0x67) +#define HDMI_CEC_OPCODE_TIMER_CLEARED_STATUS ((uint8_t) 0x43) +#define HDMI_CEC_OPCODE_TIMER_STATUS ((uint8_t) 0x35) +#define HDMI_CEC_OPCODE_CEC_VERSION ((uint8_t) 0x9E) +#define HDMI_CEC_OPCODE_GET_CEC_VERSION ((uint8_t) 0x9F) +#define HDMI_CEC_OPCODE_GIVE_PHYSICAL_ADDRESS ((uint8_t) 0x83) +#define HDMI_CEC_OPCODE_GET_MENU_LANGUAGE ((uint8_t) 0x91) +#define HDMI_CEC_OPCODE_REPORT_PHYSICAL_ADDRESS ((uint8_t) 0x84) +#define HDMI_CEC_OPCODE_SET_MENU_LANGUAGE ((uint8_t) 0x32) +#define HDMI_CEC_OPCODE_DECK_CONTROL ((uint8_t) 0x42) +#define HDMI_CEC_OPCODE_DECK_STATUS ((uint8_t) 0x1B) +#define HDMI_CEC_OPCODE_GIVE_DECK_STATUS ((uint8_t) 0x1A) +#define HDMI_CEC_OPCODE_PLAY ((uint8_t) 0x41) +#define HDMI_CEC_OPCODE_GIVE_TUNER_DEVICE_STATUS ((uint8_t) 0x08) +#define HDMI_CEC_OPCODE_SELECT_ANALOGUE_SERVICE ((uint8_t) 0x92) +#define HDMI_CEC_OPCODE_SELECT_DIGITAL_SERVICE ((uint8_t) 0x93) +#define HDMI_CEC_OPCODE_TUNER_DEVICE_STATUS ((uint8_t) 0x07) +#define HDMI_CEC_OPCODE_TUNER_STEP_DECREMENT ((uint8_t) 0x06) +#define HDMI_CEC_OPCODE_TUNER_STEP_INCREMENT ((uint8_t) 0x05) +#define HDMI_CEC_OPCODE_DEVICE_VENDOR_ID ((uint8_t) 0x87) +#define HDMI_CEC_OPCODE_GIVE_DEVICE_VENDOR_ID ((uint8_t) 0x8C) +#define HDMI_CEC_OPCODE_VENDOR_COMMAND ((uint8_t) 0x89) +#define HDMI_CEC_OPCODE_VENDOR_COMMAND_WITH_ID ((uint8_t) 0xA0) +#define HDMI_CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN ((uint8_t) 0x8A) +#define HDMI_CEC_OPCODE_VENDOR_REMOTE_BUTTON_UP ((uint8_t) 0x8B) +#define HDMI_CEC_OPCODE_SET_OSD_STRING ((uint8_t) 0x64) +#define HDMI_CEC_OPCODE_GIVE_OSD_NAME ((uint8_t) 0x46) +#define HDMI_CEC_OPCODE_SET_OSD_NAME ((uint8_t) 0x47) +#define HDMI_CEC_OPCODE_MENU_REQUEST ((uint8_t) 0x8D) +#define HDMI_CEC_OPCODE_MENU_STATUS ((uint8_t) 0x8E) +#define HDMI_CEC_OPCODE_USER_CONTROL_PRESSED ((uint8_t) 0x44) +#define HDMI_CEC_OPCODE_USER_CONTROL_RELEASED ((uint8_t) 0x45) +#define HDMI_CEC_OPCODE_GIVE_DEVICE_POWER_STATUS ((uint8_t) 0x8F) +#define HDMI_CEC_OPCODE_REPORT_POWER_STATUS ((uint8_t) 0x90) +#define HDMI_CEC_OPCODE_FEATURE_ABORT ((uint8_t) 0x00) +#define HDMI_CEC_OPCODE_ABORT ((uint8_t) 0xFF) +#define HDMI_CEC_OPCODE_GIVE_AUDIO_STATUS ((uint8_t) 0x71) +#define HDMI_CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS ((uint8_t) 0x7D) +#define HDMI_CEC_OPCODE_REPORT_AUDIO_STATUS ((uint8_t) 0x7A) +#define HDMI_CEC_OPCODE_SET_SYSTEM_AUDIO_MODE ((uint8_t) 0x72) +#define HDMI_CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST ((uint8_t) 0x70) +#define HDMI_CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS ((uint8_t) 0x7E) +#define HDMI_CEC_OPCODE_SET_AUDIO_RATE ((uint8_t) 0x9A) + + +/** + * @} + */ + +/** @defgroup STM32100B_EVAL_CEC_Exported_Macros + * @{ + */ +/* HDMI_CEC_HPD: HDMI HPD pin low */ +#define HDMI_CEC_HPD_LOW() GPIO_ResetBits(HDMI_CEC_HPD_GPIO_PORT, HDMI_CEC_HPD_PIN) +/* HDMI_CEC_HPD: HDMI HPD pin high */ +#define HDMI_CEC_HPD_HIGH() GPIO_SetBits(HDMI_CEC_HPD_GPIO_PORT, HDMI_CEC_HPD_PIN) + +/** + * @} + */ + +/** @defgroup STM32100B_EVAL_CEC_Exported_Functions + * @{ + */ +HDMI_CEC_Error HDMI_CEC_Init(void); +HDMI_CEC_Error HDMI_CEC_TransmitMessage(HDMI_CEC_Message *HDMI_CEC_TX_MessageStructure); +HDMI_CEC_Error HDMI_CEC_GetErrorStatus (void); +void HDMI_CEC_ProcessIRQSrc(void); +HDMI_CEC_Error HDMI_CEC_ReportPhysicalAddress(void); +void HDMI_CEC_CommandCallBack(void); +HDMI_CEC_Error HDMI_CEC_CheckConnectedDevices(void); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32100B_EVAL_CEC_H */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/ + diff --git a/tmp/STM32F10x_StdPeriph_Lib_V3.5.0/Utilities/STM32_EVAL/STM32100B_EVAL/stm32100b_eval_lcd.c b/tmp/STM32F10x_StdPeriph_Lib_V3.5.0/Utilities/STM32_EVAL/STM32100B_EVAL/stm32100b_eval_lcd.c new file mode 100644 index 0000000..bbf774d --- /dev/null +++ b/tmp/STM32F10x_StdPeriph_Lib_V3.5.0/Utilities/STM32_EVAL/STM32100B_EVAL/stm32100b_eval_lcd.c @@ -0,0 +1,1875 @@ +/** + ****************************************************************************** + * @file stm32100b_eval_lcd.c + * @author MCD Application Team + * @version V4.5.0 + * @date 07-March-2011 + * @brief This file includes the LCD driver for AM-240320LTNQW00H (LCD_HX8312), + * AM-240320L8TNQW00H (LCD_ILI9320), AM-240320LDTNQW00H (LCD_SPFD5408B) + * Liquid Crystal Display Module of STM32100B-EVAL board. + ****************************************************************************** + * @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, STMICROELECTRONICS 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. + * + * <h2><center>© COPYRIGHT 2011 STMicroelectronics</center></h2> + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32100b_eval_lcd.h" +#include "../Common/fonts.c" + +/** @addtogroup Utilities + * @{ + */ + +/** @addtogroup STM32_EVAL + * @{ + */ + +/** @addtogroup STM32100B_EVAL + * @{ + */ + +/** @defgroup STM32100B_EVAL_LCD + * @brief This file includes the LCD driver for AM-240320LTNQW00H (LCD_HX8312), + * AM-240320L8TNQW00H (LCD_ILI9320), AM-240320LDTNQW00H (LCD_SPFD5408B) + * Liquid Crystal Display Module of STM32100B-EVAL board. + * @{ + */ + +/** @defgroup STM32100B_EVAL_LCD_Private_Types + * @{ + */ +/** + * @} + */ + +/** @defgroup STM32100B_EVAL_LCD_Private_Defines + * @{ + */ +#define LCD_ILI9320 0x9320 +#define LCD_HX8312 0x8312 +#define LCD_SPFD5408 0x5408 +#define START_BYTE 0x70 +#define SET_INDEX 0x00 +#define READ_STATUS 0x01 +#define LCD_WRITE_REG 0x02 +#define LCD_READ_REG 0x03 +#define MAX_POLY_CORNERS 200 +#define POLY_Y(Z) ((int32_t)((Points + Z)->X)) +#define POLY_X(Z) ((int32_t)((Points + Z)->Y)) +/** + * @} + */ + +/** @defgroup STM32100B_EVAL_LCD_Private_Macros + * @{ + */ +#define ABS(X) ((X) > 0 ? (X) : -(X)) +/** + * @} + */ + +/** @defgroup STM32100B_EVAL_LCD_Private_Variables + * @{ + */ +static sFONT *LCD_Currentfonts; +/* Global variables to set the written text color */ +static __IO uint16_t TextColor = 0x0000, BackColor = 0xFFFF; +static __IO uint32_t LCDType = LCD_ILI9320; +/** + * @} + */ + +/** @defgroup STM32100B_EVAL_LCD_Private_Function_Prototypes + * @{ + */ +#ifndef USE_Delay +static void delay(vu32 nCount); +#endif /* USE_Delay*/ + +static void LCD_WriteRegHX8312(uint8_t LCD_Reg, uint8_t LCD_RegValue); +static void LCD_WriteRegILI9320(uint8_t LCD_Reg, uint16_t LCD_RegValue); +static void PutPixel(int16_t x, int16_t y); +static void LCD_PolyLineRelativeClosed(pPoint Points, uint16_t PointCount, uint16_t Closed); + +/** + * @} + */ + +/** @defgroup STM32100B_EVAL_LCD_Private_Functions + * @{ + */ + +/** + * @brief DeInitializes the LCD. + * @param None + * @retval None + */ +void LCD_DeInit(void) +{ + GPIO_InitTypeDef GPIO_InitStructure; + + /*!< LCD Display Off */ + LCD_DisplayOff(); + + /*!< LCD_SPI disable */ + SPI_Cmd(LCD_SPI, DISABLE); + + /*!< LCD_SPI DeInit */ + SPI_I2S_DeInit(LCD_SPI); + + /*!< Disable SPI clock */ + RCC_APB1PeriphClockCmd(LCD_SPI_CLK, DISABLE); + + /* Configure NCS in Output Push-Pull mode */ + GPIO_InitStructure.GPIO_Pin = LCD_NCS_PIN; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; + GPIO_Init(LCD_NCS_GPIO_PORT, &GPIO_InitStructure); + + /* Configure NWR(RNW), RS in Output Push-Pull mode */ + GPIO_InitStructure.GPIO_Pin = LCD_RS_PIN; + GPIO_Init(LCD_RS_GPIO_PORT, &GPIO_InitStructure); + + GPIO_InitStructure.GPIO_Pin = LCD_NWR_PIN; + GPIO_Init(LCD_NWR_GPIO_PORT, &GPIO_InitStructure); + + /* Configure SPI pins: SCK, MISO and MOSI */ + GPIO_InitStructure.GPIO_Pin = LCD_SPI_SCK_PIN; + GPIO_Init(LCD_SPI_SCK_GPIO_PORT, &GPIO_InitStructure); + + GPIO_InitStructure.GPIO_Pin = LCD_SPI_MISO_PIN; + GPIO_Init(LCD_SPI_MISO_GPIO_PORT, &GPIO_InitStructure); + + GPIO_InitStructure.GPIO_Pin = LCD_SPI_MOSI_PIN; + GPIO_Init(LCD_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure); +} + +/** + * @brief Setups the LCD. + * @param None + * @retval None + */ +void LCD_Setup(void) +{ +/* Configure the LCD Control pins --------------------------------------------*/ + LCD_CtrlLinesConfig(); + +/* Configure the LCD_SPI interface ----------------------------------------------*/ + LCD_SPIConfig(); + + if(LCDType == LCD_ILI9320) + { + _delay_(5); /* Delay 50 ms */ + /* Start Initial Sequence ------------------------------------------------*/ + LCD_WriteReg(LCD_REG_229, 0x8000); /* Set the internal vcore voltage */ + LCD_WriteReg(LCD_REG_0, 0x0001); /* Start internal OSC. */ + LCD_WriteReg(LCD_REG_1, 0x0100); /* set SS and SM bit */ + LCD_WriteReg(LCD_REG_2, 0x0700); /* set 1 line inversion */ + LCD_WriteReg(LCD_REG_3, 0x1030); /* set GRAM write direction and BGR=1. */ + LCD_WriteReg(LCD_REG_4, 0x0000); /* Resize register */ + LCD_WriteReg(LCD_REG_8, 0x0202); /* set the back porch and front porch */ + LCD_WriteReg(LCD_REG_9, 0x0000); /* set non-display area refresh cycle ISC[3:0] */ + LCD_WriteReg(LCD_REG_10, 0x0000); /* FMARK function */ + LCD_WriteReg(LCD_REG_12, 0x0000); /* RGB interface setting */ + LCD_WriteReg(LCD_REG_13, 0x0000); /* Frame marker Position */ + LCD_WriteReg(LCD_REG_15, 0x0000); /* RGB interface polarity */ + /* Power On sequence -----------------------------------------------------*/ + LCD_WriteReg(LCD_REG_16, 0x0000); /* SAP, BT[3:0], AP, DSTB, SLP, STB */ + LCD_WriteReg(LCD_REG_17, 0x0000); /* DC1[2:0], DC0[2:0], VC[2:0] */ + LCD_WriteReg(LCD_REG_18, 0x0000); /* VREG1OUT voltage */ + LCD_WriteReg(LCD_REG_19, 0x0000); /* VDV[4:0] for VCOM amplitude */ + _delay_(20); /* Dis-charge capacitor power voltage (200ms) */ + LCD_WriteReg(LCD_REG_16, 0x17B0); /* SAP, BT[3:0], AP, DSTB, SLP, STB */ + LCD_WriteReg(LCD_REG_17, 0x0137); /* DC1[2:0], DC0[2:0], VC[2:0] */ + _delay_(5); /* Delay 50 ms */ + LCD_WriteReg(LCD_REG_18, 0x0139); /* VREG1OUT voltage */ + _delay_(5); /* Delay 50 ms */ + LCD_WriteReg(LCD_REG_19, 0x1d00); /* VDV[4:0] for VCOM amplitude */ + LCD_WriteReg(LCD_REG_41, 0x0013); /* VCM[4:0] for VCOMH */ + _delay_(5); /* Delay 50 ms */ + LCD_WriteReg(LCD_REG_32, 0x0000); /* GRAM horizontal Address */ + LCD_WriteReg(LCD_REG_33, 0x0000); /* GRAM Vertical Address */ + /* Adjust the Gamma Curve ------------------------------------------------*/ + LCD_WriteReg(LCD_REG_48, 0x0006); + LCD_WriteReg(LCD_REG_49, 0x0101); + LCD_WriteReg(LCD_REG_50, 0x0003); + LCD_WriteReg(LCD_REG_53, 0x0106); + LCD_WriteReg(LCD_REG_54, 0x0b02); + LCD_WriteReg(LCD_REG_55, 0x0302); + LCD_WriteReg(LCD_REG_56, 0x0707); + LCD_WriteReg(LCD_REG_57, 0x0007); + LCD_WriteReg(LCD_REG_60, 0x0600); + LCD_WriteReg(LCD_REG_61, 0x020b); + + /* Set GRAM area ---------------------------------------------------------*/ + LCD_WriteReg(LCD_REG_80, 0x0000); /* Horizontal GRAM Start Address */ + LCD_WriteReg(LCD_REG_81, 0x00EF); /* Horizontal GRAM End Address */ + LCD_WriteReg(LCD_REG_82, 0x0000); /* Vertical GRAM Start Address */ + LCD_WriteReg(LCD_REG_83, 0x013F); /* Vertical GRAM End Address */ + LCD_WriteReg(LCD_REG_96, 0x2700); /* Gate Scan Line */ + LCD_WriteReg(LCD_REG_97, 0x0001); /* NDL,VLE, REV */ + LCD_WriteReg(LCD_REG_106, 0x0000); /* set scrolling line */ + /* Partial Display Control -----------------------------------------------*/ + LCD_WriteReg(LCD_REG_128, 0x0000); + LCD_WriteReg(LCD_REG_129, 0x0000); + LCD_WriteReg(LCD_REG_130, 0x0000); + LCD_WriteReg(LCD_REG_131, 0x0000); + LCD_WriteReg(LCD_REG_132, 0x0000); + LCD_WriteReg(LCD_REG_133, 0x0000); + /* Panel Control ---------------------------------------------------------*/ + LCD_WriteReg(LCD_REG_144, 0x0010); + LCD_WriteReg(LCD_REG_146, 0x0000); + LCD_WriteReg(LCD_REG_147, 0x0003); + LCD_WriteReg(LCD_REG_149, 0x0110); + LCD_WriteReg(LCD_REG_151, 0x0000); + LCD_WriteReg(LCD_REG_152, 0x0000); + /* Set GRAM write direction and BGR = 1 */ + /* I/D=01 (Horizontal : increment, Vertical : decrement) */ + /* AM=1 (address is updated in vertical writing direction) */ + LCD_WriteReg(LCD_REG_3, 0x1018); + LCD_WriteReg(LCD_REG_7, 0x0173); /* 262K color and display ON */ + } + else if(LCDType == LCD_SPFD5408) + { + /* Start Initial Sequence --------------------------------------------------*/ + LCD_WriteReg(LCD_REG_227, 0x3008); /* Set internal timing */ + LCD_WriteReg(LCD_REG_231, 0x0012); /* Set internal timing */ + LCD_WriteReg(LCD_REG_239, 0x1231); /* Set internal timing */ + LCD_WriteReg(LCD_REG_1, 0x0100); /* Set SS and SM bit */ + LCD_WriteReg(LCD_REG_2, 0x0700); /* Set 1 line inversion */ + LCD_WriteReg(LCD_REG_3, 0x1030); /* Set GRAM write direction and BGR=1. */ + LCD_WriteReg(LCD_REG_4, 0x0000); /* Resize register */ + LCD_WriteReg(LCD_REG_8, 0x0202); /* Set the back porch and front porch */ + LCD_WriteReg(LCD_REG_9, 0x0000); /* Set non-display area refresh cycle ISC[3:0] */ + LCD_WriteReg(LCD_REG_10, 0x0000); /* FMARK function */ + LCD_WriteReg(LCD_REG_12, 0x0000); /* RGB interface setting */ + LCD_WriteReg(LCD_REG_13, 0x0000); /* Frame marker Position */ + LCD_WriteReg(LCD_REG_15, 0x0000); /* RGB interface polarity */ + /* Power On sequence -------------------------------------------------------*/ + LCD_WriteReg(LCD_REG_16, 0x0000); /* SAP, BT[3:0], AP, DSTB, SLP, STB */ + LCD_WriteReg(LCD_REG_17, 0x0000); /* DC1[2:0], DC0[2:0], VC[2:0] */ + LCD_WriteReg(LCD_REG_18, 0x0000); /* VREG1OUT voltage */ + LCD_WriteReg(LCD_REG_19, 0x0000); /* VDV[4:0] for VCOM amplitude */ + _delay_(20); /* Dis-charge capacitor power voltage (200ms) */ + LCD_WriteReg(LCD_REG_17, 0x0007); /* DC1[2:0], DC0[2:0], VC[2:0] */ + _delay_(5); /* Delay 50 ms */ + LCD_WriteReg(LCD_REG_16, 0x12B0); /* SAP, BT[3:0], AP, DSTB, SLP, STB */ + _delay_(5); /* Delay 50 ms */ + LCD_WriteReg(LCD_REG_18, 0x01BD); /* External reference voltage= Vci */ + _delay_(5); /* Delay 50 ms */ + LCD_WriteReg(LCD_REG_19, 0x1400); /* VDV[4:0] for VCOM amplitude */ + LCD_WriteReg(LCD_REG_41, 0x000E); /* VCM[4:0] for VCOMH */ + _delay_(5); /* Delay 50 ms */ + LCD_WriteReg(LCD_REG_32, 0x0000); /* GRAM horizontal Address */ + LCD_WriteReg(LCD_REG_33, 0x013F); /* GRAM Vertical Address */ + /* Adjust the Gamma Curve --------------------------------------------------*/ + LCD_WriteReg(LCD_REG_48, 0x0007); + LCD_WriteReg(LCD_REG_49, 0x0302); + LCD_WriteReg(LCD_REG_50, 0x0105); + LCD_WriteReg(LCD_REG_53, 0x0206); + LCD_WriteReg(LCD_REG_54, 0x0808); + LCD_WriteReg(LCD_REG_55, 0x0206); + LCD_WriteReg(LCD_REG_56, 0x0504); + LCD_WriteReg(LCD_REG_57, 0x0007); + LCD_WriteReg(LCD_REG_60, 0x0105); + LCD_WriteReg(LCD_REG_61, 0x0808); + /* Set GRAM area -----------------------------------------------------------*/ + LCD_WriteReg(LCD_REG_80, 0x0000); /* Horizontal GRAM Start Address */ + LCD_WriteReg(LCD_REG_81, 0x00EF); /* Horizontal GRAM End Address */ + LCD_WriteReg(LCD_REG_82, 0x0000); /* Vertical GRAM Start Address */ + LCD_WriteReg(LCD_REG_83, 0x013F); /* Vertical GRAM End Address */ + LCD_WriteReg(LCD_REG_96, 0xA700); /* Gate Scan Line */ + LCD_WriteReg(LCD_REG_97, 0x0001); /* NDL,VLE, REV */ + LCD_WriteReg(LCD_REG_106, 0x0000); /* Set scrolling line */ + /* Partial Display Control -------------------------------------------------*/ + LCD_WriteReg(LCD_REG_128, 0x0000); + LCD_WriteReg(LCD_REG_129, 0x0000); + LCD_WriteReg(LCD_REG_130, 0x0000); + LCD_WriteReg(LCD_REG_131, 0x0000); + LCD_WriteReg(LCD_REG_132, 0x0000); + LCD_WriteReg(LCD_REG_133, 0x0000); + /* Panel Control -----------------------------------------------------------*/ + LCD_WriteReg(LCD_REG_144, 0x0010); + LCD_WriteReg(LCD_REG_146, 0x0000); + LCD_WriteReg(LCD_REG_147, 0x0003); + LCD_WriteReg(LCD_REG_149, 0x0110); + LCD_WriteReg(LCD_REG_151, 0x0000); + LCD_WriteReg(LCD_REG_152, 0x0000); + /* Set GRAM write direction and BGR = 1 + I/D=01 (Horizontal : increment, Vertical : decrement) + AM=1 (address is updated in vertical writing direction) */ + LCD_WriteReg(LCD_REG_3, 0x1018); + LCD_WriteReg(LCD_REG_7, 0x0112); /* 262K color and display ON */ + } + else if(LCDType == LCD_HX8312) + { + /* Enable the LCD Oscillator ---------------------------------------------*/ + LCD_WriteReg(LCD_REG_1, 0x10); + LCD_WriteReg(LCD_REG_0, 0xA0); + LCD_WriteReg(LCD_REG_3, 0x01); + _delay_(1); /* Delay 10 ms */ + LCD_WriteReg(LCD_REG_3, 0x00); + LCD_WriteReg(LCD_REG_43, 0x04); + + LCD_WriteReg(LCD_REG_40, 0x18); + LCD_WriteReg(LCD_REG_26, 0x05); + LCD_WriteReg(LCD_REG_37, 0x05); + LCD_WriteReg(LCD_REG_25, 0x00); + + /* LCD Power On ----------------------------------------------------------*/ + LCD_WriteReg(LCD_REG_28, 0x73); + LCD_WriteReg(LCD_REG_36, 0x74); + LCD_WriteReg(LCD_REG_30, 0x01); + LCD_WriteReg(LCD_REG_24, 0xC1); + _delay_(1); /* Delay 10 ms */ + LCD_WriteReg(LCD_REG_24, 0xE1); + LCD_WriteReg(LCD_REG_24, 0xF1); + _delay_(6); /* Delay 60 ms */ + LCD_WriteReg(LCD_REG_24, 0xF5); + _delay_(6); /* Delay 60 ms */ + LCD_WriteReg(LCD_REG_27, 0x09); + _delay_(1); /* Delay 10 ms */ + LCD_WriteReg(LCD_REG_31, 0x11); + LCD_WriteReg(LCD_REG_32, 0x0E); + LCD_WriteReg(LCD_REG_30, 0x81); + _delay_(1); /* Delay 10 ms */ + + /* Chip Set --------------------------------------------------------------*/ + LCD_WriteReg(LCD_REG_157, 0x00); + LCD_WriteReg(LCD_REG_192, 0x00); + + LCD_WriteReg(LCD_REG_14, 0x00); + LCD_WriteReg(LCD_REG_15, 0x00); + LCD_WriteReg(LCD_REG_16, 0x00); + LCD_WriteReg(LCD_REG_17, 0x00); + LCD_WriteReg(LCD_REG_18, 0x00); + LCD_WriteReg(LCD_REG_19, 0x00); + LCD_WriteReg(LCD_REG_20, 0x00); + LCD_WriteReg(LCD_REG_21, 0x00); + LCD_WriteReg(LCD_REG_22, 0x00); + LCD_WriteReg(LCD_REG_23, 0x00); + + LCD_WriteReg(LCD_REG_52, 0x01); + LCD_WriteReg(LCD_REG_53, 0x00); + LCD_WriteReg(LCD_REG_75, 0x00); + LCD_WriteReg(LCD_REG_76, 0x00); + LCD_WriteReg(LCD_REG_78, 0x00); + LCD_WriteReg(LCD_REG_79, 0x00); + LCD_WriteReg(LCD_REG_80, 0x00); + + LCD_WriteReg(LCD_REG_60, 0x00); + LCD_WriteReg(LCD_REG_61, 0x00); + LCD_WriteReg(LCD_REG_62, 0x01); + LCD_WriteReg(LCD_REG_63, 0x3F); + LCD_WriteReg(LCD_REG_64, 0x02); + LCD_WriteReg(LCD_REG_65, 0x02); + LCD_WriteReg(LCD_REG_66, 0x00); + LCD_WriteReg(LCD_REG_67, 0x00); + LCD_WriteReg(LCD_REG_68, 0x00); + LCD_WriteReg(LCD_REG_69, 0x00); + LCD_WriteReg(LCD_REG_70, 0xEF); + LCD_WriteReg(LCD_REG_71, 0x00); + LCD_WriteReg(LCD_REG_72, 0x00); + LCD_WriteReg(LCD_REG_73, 0x01); + LCD_WriteReg(LCD_REG_74, 0x3F); + + LCD_WriteReg(LCD_REG_29, 0x08); /* R29:Gate scan direction setting */ + + LCD_WriteReg(LCD_REG_134, 0x00); + LCD_WriteReg(LCD_REG_135, 0x30); + LCD_WriteReg(LCD_REG_136, 0x02); + LCD_WriteReg(LCD_REG_137, 0x05); + + LCD_WriteReg(LCD_REG_141, 0x01); /* R141:Register set-up mode for one line clock */ + LCD_WriteReg(LCD_REG_139, 0x20); /* R139:One line SYSCLK number in one-line */ + LCD_WriteReg(LCD_REG_51, 0x01); /* R51:N line inversion setting */ + LCD_WriteReg(LCD_REG_55, 0x01); /* R55:Scanning method setting */ + LCD_WriteReg(LCD_REG_118, 0x00); + + /* Gamma Set -------------------------------------------------------------*/ + LCD_WriteReg(LCD_REG_143, 0x10); + LCD_WriteReg(LCD_REG_144, 0x67); + LCD_WriteReg(LCD_REG_145, 0x07); + LCD_WriteReg(LCD_REG_146, 0x65); + LCD_WriteReg(LCD_REG_147, 0x07); + LCD_WriteReg(LCD_REG_148, 0x01); + LCD_WriteReg(LCD_REG_149, 0x76); + LCD_WriteReg(LCD_REG_150, 0x56); + LCD_WriteReg(LCD_REG_151, 0x00); + LCD_WriteReg(LCD_REG_152, 0x06); + LCD_WriteReg(LCD_REG_153, 0x03); + LCD_WriteReg(LCD_REG_154, 0x00); + + /* Display On ------------------------------------------------------------*/ + LCD_WriteReg(LCD_REG_1, 0x50); + LCD_WriteReg(LCD_REG_5, 0x04); + LCD_WriteReg(LCD_REG_0, 0x80); + LCD_WriteReg(LCD_REG_59, 0x01); + _delay_(4); /* Delay 40 ms */ + LCD_WriteReg(LCD_REG_0, 0x20); + } +} + + +/** + * @brief Initializes the LCD. + * @param None + * @retval None + */ +void STM32100B_LCD_Init(void) +{ + /* Setups the LCD */ + LCD_Setup(); + /* Try to read new LCD controller ID 0x9320 */ + if (LCD_ReadReg(LCD_REG_0) == LCD_ILI9320) + { + LCDType = LCD_ILI9320; + } + else + { + LCDType = LCD_SPFD5408; + /* Setups the LCD */ + LCD_Setup(); + /* Try to read new LCD controller ID 0x5408 */ + if (LCD_ReadReg(LCD_REG_0) != LCD_SPFD5408) + { + LCDType = LCD_HX8312; + /* Setups the LCD */ + LCD_Setup(); + } + } + LCD_SetFont(&LCD_DEFAULT_FONT); +} + +/** + * @brief Sets the LCD Text and Background colors. + * @param _TextColor: specifies the Text Color. + * @param _BackColor: specifies the Background Color. + * @retval None + */ +void LCD_SetColors(__IO uint16_t _TextColor, __IO uint16_t _BackColor) +{ + TextColor = _TextColor; + BackColor = _BackColor; +} + +/** + * @brief Gets the LCD Text and Background colors. + * @param _TextColor: pointer to the variable that will contain the Text + Color. + * @param _BackColor: pointer to the variable that will contain the Background + Color. + * @retval None + */ +void LCD_GetColors(__IO uint16_t *_TextColor, __IO uint16_t *_BackColor) +{ + *_TextColor = TextColor; *_BackColor = BackColor; +} + +/** + * @brief Sets the Text color. + * @param Color: specifies the Text color code RGB(5-6-5). + * @retval None + */ +void LCD_SetTextColor(__IO uint16_t Color) +{ + TextColor = Color; +} + + +/** + * @brief Sets the Background color. + * @param Color: specifies the Background color code RGB(5-6-5). + * @retval None + */ +void LCD_SetBackColor(__IO uint16_t Color) +{ + BackColor = Color; +} + +/** + * @brief Sets the Text Font. + * @param fonts: specifies the font to be used. + * @retval None + */ +void LCD_SetFont(sFONT *fonts) +{ + LCD_Currentfonts = fonts; +} + +/** + * @brief Gets the Text Font. + * @param None. + * @retval the used font. + */ +sFONT *LCD_GetFont(void) +{ + return LCD_Currentfonts; +} + +/** + * @brief Clears the selected line. + * @param Line: the Line to be cleared. + * This parameter can be one of the following values: + * @arg Linex: where x can be 0..n + * @retval None + */ +void LCD_ClearLine(uint8_t Line) +{ + uint16_t refcolumn = LCD_PIXEL_WIDTH - 1; + /* Send the string character by character on lCD */ + while (((refcolumn + 1) & 0xFFFF) >= LCD_Currentfonts->Width) + { + /* Display one character on LCD */ + LCD_DisplayChar(Line, refcolumn, ' '); + /* Decrement the column position by 16 */ + refcolumn -= LCD_Currentfonts->Width; + } +} + + +/** + * @brief Clears the hole LCD. + * @param Color: the color of the background. + * @retval None + */ +void LCD_Clear(uint16_t Color) +{ + uint32_t index = 0; + + LCD_SetCursor(0x00, 0x013F); + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */ + } + for(index = 0; index < 76800; index++) + { + LCD_WriteRAM(Color); + } + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_SET); + } +} + + +/** + * @brief Sets the cursor position. + * @param Xpos: specifies the X position. + * @param Ypos: specifies the Y position. + * @retval None + */ +void LCD_SetCursor(uint8_t Xpos, uint16_t Ypos) +{ + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_WriteReg(LCD_REG_32, Xpos); + LCD_WriteReg(LCD_REG_33, Ypos); + } + else if(LCDType == LCD_HX8312) + { + LCD_WriteReg(LCD_REG_66, Xpos); + LCD_WriteReg(LCD_REG_67, ((Ypos & 0x100)>> 8)); + LCD_WriteReg(LCD_REG_68, (Ypos & 0xFF)); + } +} + + +/** + * @brief Draws a character on LCD. + * @param Xpos: the Line where to display the character shape. + * @param Ypos: start column address. + * @param c: pointer to the character data. + * @retval None + */ +void LCD_DrawChar(uint8_t Xpos, uint16_t Ypos, const uint16_t *c) +{ + uint32_t index = 0, i = 0; + uint8_t Xaddress = 0; + + Xaddress = Xpos; + + LCD_SetCursor(Xaddress, Ypos); + + for(index = 0; index < LCD_Currentfonts->Height; index++) + { + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */ + } + for(i = 0; i < LCD_Currentfonts->Width; i++) + { + if((((c[index] & ((0x80 << ((LCD_Currentfonts->Width / 12 ) * 8 ) ) >> i)) == 0x00) &&(LCD_Currentfonts->Width <= 12))|| + (((c[index] & (0x1 << i)) == 0x00)&&(LCD_Currentfonts->Width > 12 ))) + + { + LCD_WriteRAM(BackColor); + } + else + { + LCD_WriteRAM(TextColor); + } + } + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_SET); + } + Xaddress++; + LCD_SetCursor(Xaddress, Ypos); + } +} + + +/** + * @brief Displays one character (16dots width, 24dots height). + * @param Line: the Line where to display the character shape . + * This parameter can be one of the following values: + * @arg Linex: where x can be 0..9 + * @param Column: start column address. + * @param Ascii: character ascii code, must be between 0x20 and 0x7E. + * @retval None + */ +void LCD_DisplayChar(uint8_t Line, uint16_t Column, uint8_t Ascii) +{ + Ascii -= 32; + LCD_DrawChar(Line, Column, &LCD_Currentfonts->table[Ascii * LCD_Currentfonts->Height]); +} + + +/** + * @brief Displays a maximum of 20 char on the LCD. + * @param Line: the Line where to display the character shape . + * This parameter can be one of the following values: + * @arg Linex: where x can be 0..9 + * @param *ptr: pointer to string to display on LCD. + * @retval None + */ +void LCD_DisplayStringLine(uint8_t Line, uint8_t *ptr) +{ + uint16_t refcolumn = LCD_PIXEL_WIDTH - 1; + + /* Send the string character by character on lCD */ + while ((*ptr != 0) & (((refcolumn + 1) & 0xFFFF) >= LCD_Currentfonts->Width)) + { + /* Display one character on LCD */ + LCD_DisplayChar(Line, refcolumn, *ptr); + /* Decrement the column position by 16 */ + refcolumn -= LCD_Currentfonts->Width; + /* Point on the next character */ + ptr++; + } +} + + +/** + * @brief Sets a display window + * @param Xpos: specifies the X buttom left position. + * @param Ypos: specifies the Y buttom left position. + * @param Height: display window height. + * @param Width: display window width. + * @retval None + */ +void LCD_SetDisplayWindow(uint8_t Xpos, uint16_t Ypos, uint8_t Height, uint16_t Width) +{ + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + /* Horizontal GRAM Start Address */ + if(Xpos >= Height) + { + LCD_WriteReg(LCD_REG_80, (Xpos - Height + 1)); + } + else + { + LCD_WriteReg(LCD_REG_80, 0); + } + /* Horizontal GRAM End Address */ + LCD_WriteReg(LCD_REG_81, Xpos); + /* Vertical GRAM Start Address */ + if(Ypos >= Width) + { + LCD_WriteReg(LCD_REG_82, (Ypos - Width + 1)); + } + else + { + LCD_WriteReg(LCD_REG_82, 0); + } + /* Vertical GRAM End Address */ + LCD_WriteReg(LCD_REG_83, Ypos); + } + else if(LCDType == LCD_HX8312) + { + LCD_WriteReg(LCD_REG_1, 0xD0); + LCD_WriteReg(LCD_REG_5, 0x14); + + LCD_WriteReg(LCD_REG_69, (Xpos - Height + 1)); + LCD_WriteReg(LCD_REG_70, Xpos); + + LCD_WriteReg(LCD_REG_71, (((Ypos - Width + 1) & 0x100)>> 8)); + LCD_WriteReg(LCD_REG_72, ((Ypos - Width + 1) & 0xFF)); + LCD_WriteReg(LCD_REG_73, ((Ypos & 0x100)>> 8)); + LCD_WriteReg(LCD_REG_74, (Ypos & 0xFF)); + } + LCD_SetCursor(Xpos, Ypos); +} + + +/** + * @brief Disables LCD Window mode. + * @param None + * @retval None + */ +void LCD_WindowModeDisable(void) +{ + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_SetDisplayWindow(239, 0x13F, 240, 320); + LCD_WriteReg(LCD_REG_3, 0x1018); + } + else if(LCDType == LCD_HX8312) + { + LCD_WriteReg(LCD_REG_1, 0x50); + LCD_WriteReg(LCD_REG_5, 0x04); + } + +} + +/** + * @brief Displays a line. + * @param Xpos: specifies the X position. + * @param Ypos: specifies the Y position. + * @param Length: line length. + * @param Direction: line direction. + * This parameter can be one of the following values: Vertical or Horizontal. + * @retval None + */ +void LCD_DrawLine(uint8_t Xpos, uint16_t Ypos, uint16_t Length, uint8_t Direction) +{ + uint32_t i = 0; + + LCD_SetCursor(Xpos, Ypos); + if(Direction == LCD_DIR_HORIZONTAL) + { + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */ + } + for(i = 0; i < Length; i++) + { + LCD_WriteRAM(TextColor); + } + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_SET); + } + } + else + { + for(i = 0; i < Length; i++) + { + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_WriteRAMWord(TextColor); + } + else if(LCDType == LCD_HX8312) + { + LCD_WriteRAM(TextColor); + } + Xpos++; + LCD_SetCursor(Xpos, Ypos); + } + } +} + + +/** + * @brief Displays a rectangle. + * @param Xpos: specifies the X position. + * @param Ypos: specifies the Y position. + * @param Height: display rectangle height. + * @param Width: display rectangle width. + * @retval None + */ +void LCD_DrawRect(uint8_t Xpos, uint16_t Ypos, uint8_t Height, uint16_t Width) +{ + LCD_DrawLine(Xpos, Ypos, Width, LCD_DIR_HORIZONTAL); + LCD_DrawLine((Xpos + Height), Ypos, Width, LCD_DIR_HORIZONTAL); + + LCD_DrawLine(Xpos, Ypos, Height, LCD_DIR_VERTICAL); + LCD_DrawLine(Xpos, (Ypos - Width + 1), Height, LCD_DIR_VERTICAL); +} + + +/** + * @brief Displays a circle. + * @param Xpos: specifies the X position. + * @param Ypos: specifies the Y position. + * @param Radius + * @retval None + */ +void LCD_DrawCircle(uint8_t Xpos, uint16_t Ypos, uint16_t Radius) +{ + int32_t D;/* Decision Variable */ + uint32_t CurX;/* Current X Value */ + uint32_t CurY;/* Current Y Value */ + + D = 3 - (Radius << 1); + CurX = 0; + CurY = Radius; + + while (CurX <= CurY) + { + LCD_SetCursor(Xpos + CurX, Ypos + CurY); + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_WriteRAMWord(TextColor); + } + else if(LCDType == LCD_HX8312) + { + LCD_WriteRAM(TextColor); + } + LCD_SetCursor(Xpos + CurX, Ypos - CurY); + + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_WriteRAMWord(TextColor); + } + else if(LCDType == LCD_HX8312) + { + LCD_WriteRAM(TextColor); + } + LCD_SetCursor(Xpos - CurX, Ypos + CurY); + + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_WriteRAMWord(TextColor); + } + else if(LCDType == LCD_HX8312) + { + LCD_WriteRAM(TextColor); + } + LCD_SetCursor(Xpos - CurX, Ypos - CurY); + + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_WriteRAMWord(TextColor); + } + else if(LCDType == LCD_HX8312) + { + LCD_WriteRAM(TextColor); + } + LCD_SetCursor(Xpos + CurY, Ypos + CurX); + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_WriteRAMWord(TextColor); + } + else if(LCDType == LCD_HX8312) + { + LCD_WriteRAM(TextColor); + } + LCD_SetCursor(Xpos + CurY, Ypos - CurX); + + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_WriteRAMWord(TextColor); + } + else if(LCDType == LCD_HX8312) + { + LCD_WriteRAM(TextColor); + } + LCD_SetCursor(Xpos - CurY, Ypos + CurX); + + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_WriteRAMWord(TextColor); + } + else if(LCDType == LCD_HX8312) + { + LCD_WriteRAM(TextColor); + } + LCD_SetCursor(Xpos - CurY, Ypos - CurX); + + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_WriteRAMWord(TextColor); + } + else if(LCDType == LCD_HX8312) + { + LCD_WriteRAM(TextColor); + } + if (D < 0) + { + D += (CurX << 2) + 6; + } + else + { + D += ((CurX - CurY) << 2) + 10; + CurY--; + } + CurX++; + } +} + + +/** + * @brief Displays a monocolor picture. + * @param Pict: pointer to the picture array. + * @retval None + */ +void LCD_DrawMonoPict(const uint32_t *Pict) +{ + uint32_t index = 0, i = 0; + LCD_SetCursor(0, (LCD_PIXEL_WIDTH - 1)); + + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */ + } + + for(index = 0; index < 2400; index++) + { + for(i = 0; i < 32; i++) + { + if((Pict[index] & (1 << i)) == 0x00) + { + LCD_WriteRAM(BackColor); + } + else + { + LCD_WriteRAM(TextColor); + } + } + } + + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_SET); + } +} + +#ifdef USE_LCD_DrawBMP +/** + * @brief Displays a bitmap picture loaded in the SPI Flash. + * @param BmpAddress: Bmp picture address in the SPI Flash. + * @retval None + */ +void LCD_DrawBMP(uint32_t BmpAddress) +{ + uint32_t i = 0, size = 0; + /* Read bitmap size */ + sFLASH_ReadBuffer((uint8_t*)&size, BmpAddress + 2, 4); + /* get bitmap data address offset */ + sFLASH_ReadBuffer((uint8_t*)&i, BmpAddress + 10, 4); + + size = (size - i)/2; + sFLASH_StartReadSequence(BmpAddress + i); + /* Disable LCD_SPI */ + SPI_Cmd(LCD_SPI, DISABLE); + /* SPI in 16-bit mode */ + SPI_DataSizeConfig(LCD_SPI, SPI_DataSize_16b); + /* Enable LCD_SPI */ + SPI_Cmd(LCD_SPI, ENABLE); + + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + /* Set GRAM write direction and BGR = 1 */ + /* I/D=00 (Horizontal : decrement, Vertical : decrement) */ + /* AM=1 (address is updated in vertical writing direction) */ + LCD_WriteReg(LCD_REG_3, 0x1008); + LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */ + } + + /* Read bitmap data from SPI Flash and send them to LCD */ + for(i = 0; i < size; i++) + { + LCD_WriteRAM(__REV16(sFLASH_SendHalfWord(0xA5A5))); + } + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_SET); + } + + /* Deselect the FLASH: Chip Select high */ + sFLASH_CS_HIGH(); + /* Disable LCD_SPI */ + SPI_Cmd(LCD_SPI, DISABLE); + /* SPI in 8-bit mode */ + SPI_DataSizeConfig(LCD_SPI, SPI_DataSize_8b); + /* Enable LCD_SPI */ + SPI_Cmd(LCD_SPI, ENABLE); + + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + /* Set GRAM write direction and BGR = 1 */ + /* I/D = 01 (Horizontal : increment, Vertical : decrement) */ + /* AM = 1 (address is updated in vertical writing direction) */ + LCD_WriteReg(LCD_REG_3, 0x1018); + } +} +#endif /* USE_LCD_DrawBMP */ + +/** + * @brief Displays a full rectangle. + * @param Xpos: specifies the X position. + * @param Ypos: specifies the Y position. + * @param Height: rectangle height. + * @param Width: rectangle width. + * @retval None + */ +void LCD_DrawFullRect(uint16_t Xpos, uint16_t Ypos, uint16_t Width, uint16_t Height) +{ + LCD_SetTextColor(TextColor); + + LCD_DrawLine(Xpos, Ypos, Width, LCD_DIR_HORIZONTAL); + LCD_DrawLine((Xpos + Height), Ypos, Width, LCD_DIR_HORIZONTAL); + + LCD_DrawLine(Xpos, Ypos, Height, LCD_DIR_VERTICAL); + LCD_DrawLine(Xpos, (Ypos - Width + 1), Height, LCD_DIR_VERTICAL); + + Width -= 2; + Height--; + Ypos--; + + LCD_SetTextColor(BackColor); + + while(Height--) + { + LCD_DrawLine(++Xpos, Ypos, Width, LCD_DIR_HORIZONTAL); + } + + LCD_SetTextColor(TextColor); +} + +/** + * @brief Displays a full circle. + * @param Xpos: specifies the X position. + * @param Ypos: specifies the Y position. + * @param Radius + * @retval None + */ +void LCD_DrawFullCircle(uint16_t Xpos, uint16_t Ypos, uint16_t Radius) +{ + int32_t D; /* Decision Variable */ + uint32_t CurX;/* Current X Value */ + uint32_t CurY;/* Current Y Value */ + + D = 3 - (Radius << 1); + + CurX = 0; + CurY = Radius; + + LCD_SetTextColor(BackColor); + + while (CurX <= CurY) + { + if(CurY > 0) + { + LCD_DrawLine(Xpos - CurX, Ypos + CurY, 2*CurY, LCD_DIR_HORIZONTAL); + LCD_DrawLine(Xpos + CurX, Ypos + CurY, 2*CurY, LCD_DIR_HORIZONTAL); + } + + if(CurX > 0) + { + LCD_DrawLine(Xpos - CurY, Ypos + CurX, 2*CurX, LCD_DIR_HORIZONTAL); + LCD_DrawLine(Xpos + CurY, Ypos + CurX, 2*CurX, LCD_DIR_HORIZONTAL); + } + if (D < 0) + { + D += (CurX << 2) + 6; + } + else + { + D += ((CurX - CurY) << 2) + 10; + CurY--; + } + CurX++; + } + + LCD_SetTextColor(TextColor); + LCD_DrawCircle(Xpos, Ypos, Radius); +} + +/** + * @brief Displays an uni line (between two points). + * @param x1: specifies the point 1 x position. + * @param y1: specifies the point 1 y position. + * @param x2: specifies the point 2 x position. + * @param y2: specifies the point 2 y position. + * @retval None + */ +void LCD_DrawUniLine(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2) +{ + int16_t deltax = 0, deltay = 0, x = 0, y = 0, xinc1 = 0, xinc2 = 0, + yinc1 = 0, yinc2 = 0, den = 0, num = 0, numadd = 0, numpixels = 0, + curpixel = 0; + + deltax = ABS(x2 - x1); /* The difference between the x's */ + deltay = ABS(y2 - y1); /* The difference between the y's */ + x = x1; /* Start x off at the first pixel */ + y = y1; /* Start y off at the first pixel */ + + if (x2 >= x1) /* The x-values are increasing */ + { + xinc1 = 1; + xinc2 = 1; + } + else /* The x-values are decreasing */ + { + xinc1 = -1; + xinc2 = -1; + } + + if (y2 >= y1) /* The y-values are increasing */ + { + yinc1 = 1; + yinc2 = 1; + } + else /* The y-values are decreasing */ + { + yinc1 = -1; + yinc2 = -1; + } + + if (deltax >= deltay) /* There is at least one x-value for every y-value */ + { + xinc1 = 0; /* Don't change the x when numerator >= denominator */ + yinc2 = 0; /* Don't change the y for every iteration */ + den = deltax; + num = deltax / 2; + numadd = deltay; + numpixels = deltax; /* There are more x-values than y-values */ + } + else /* There is at least one y-value for every x-value */ + { + xinc2 = 0; /* Don't change the x for every iteration */ + yinc1 = 0; /* Don't change the y when numerator >= denominator */ + den = deltay; + num = deltay / 2; + numadd = deltax; + numpixels = deltay; /* There are more y-values than x-values */ + } + + for (curpixel = 0; curpixel <= numpixels; curpixel++) + { + PutPixel(x, y); /* Draw the current pixel */ + num += numadd; /* Increase the numerator by the top of the fraction */ + if (num >= den) /* Check if numerator >= denominator */ + { + num -= den; /* Calculate the new numerator value */ + x += xinc1; /* Change the x as appropriate */ + y += yinc1; /* Change the y as appropriate */ + } + x += xinc2; /* Change the x as appropriate */ + y += yinc2; /* Change the y as appropriate */ + } +} + +/** + * @brief Displays an polyline (between many points). + * @param Points: pointer to the points array. + * @param PointCount: Number of points. + * @retval None + */ +void LCD_PolyLine(pPoint Points, uint16_t PointCount) +{ + int16_t X = 0, Y = 0; + + if(PointCount < 2) + { + return; + } + + while(--PointCount) + { + X = Points->X; + Y = Points->Y; + Points++; + LCD_DrawUniLine(X, Y, Points->X, Points->Y); + } +} + +/** + * @brief Displays an relative polyline (between many points). + * @param Points: pointer to the points array. + * @param PointCount: Number of points. + * @param Closed: specifies if the draw is closed or not. + * 1: closed, 0 : not closed. + * @retval None + */ +static void LCD_PolyLineRelativeClosed(pPoint Points, uint16_t PointCount, uint16_t Closed) +{ + int16_t X = 0, Y = 0; + pPoint First = Points; + + if(PointCount < 2) + { + return; + } + X = Points->X; + Y = Points->Y; + while(--PointCount) + { + Points++; + LCD_DrawUniLine(X, Y, X + Points->X, Y + Points->Y); + X = X + Points->X; + Y = Y + Points->Y; + } + if(Closed) + { + LCD_DrawUniLine(First->X, First->Y, X, Y); + } +} + +/** + * @brief Displays a closed polyline (between many points). + * @param Points: pointer to the points array. + * @param PointCount: Number of points. + * @retval None + */ +void LCD_ClosedPolyLine(pPoint Points, uint16_t PointCount) +{ + LCD_PolyLine(Points, PointCount); + LCD_DrawUniLine(Points->X, Points->Y, (Points+PointCount-1)->X, (Points+PointCount-1)->Y); +} + +/** + * @brief Displays a relative polyline (between many points). + * @param Points: pointer to the points array. + * @param PointCount: Number of points. + * @retval None + */ +void LCD_PolyLineRelative(pPoint Points, uint16_t PointCount) +{ + LCD_PolyLineRelativeClosed(Points, PointCount, 0); +} + +/** + * @brief Displays a closed relative polyline (between many points). + * @param Points: pointer to the points array. + * @param PointCount: Number of points. + * @retval None + */ +void LCD_ClosedPolyLineRelative(pPoint Points, uint16_t PointCount) +{ + LCD_PolyLineRelativeClosed(Points, PointCount, 1); +} + + +/** + * @brief Displays a full polyline (between many points). + * @param Points: pointer to the points array. + * @param PointCount: Number of points. + * @retval None + */ +void LCD_FillPolyLine(pPoint Points, uint16_t PointCount) +{ + /* public-domain code by Darel Rex Finley, 2007 */ + uint16_t nodes = 0, nodeX[MAX_POLY_CORNERS], pixelX = 0, pixelY = 0, i = 0, + j = 0, swap = 0; + uint16_t IMAGE_LEFT = 0, IMAGE_RIGHT = 0, IMAGE_TOP = 0, IMAGE_BOTTOM = 0; + + IMAGE_LEFT = IMAGE_RIGHT = Points->X; + IMAGE_TOP= IMAGE_BOTTOM = Points->Y; + + for(i = 1; i < PointCount; i++) + { + pixelX = POLY_X(i); + if(pixelX < IMAGE_LEFT) + { + IMAGE_LEFT = pixelX; + } + if(pixelX > IMAGE_RIGHT) + { + IMAGE_RIGHT = pixelX; + } + + pixelY = POLY_Y(i); + if(pixelY < IMAGE_TOP) + { + IMAGE_TOP = pixelY; + } + if(pixelY > IMAGE_BOTTOM) + { + IMAGE_BOTTOM = pixelY; + } + } + + LCD_SetTextColor(BackColor); + + /* Loop through the rows of the image. */ + for (pixelY = IMAGE_TOP; pixelY < IMAGE_BOTTOM; pixelY++) + { + /* Build a list of nodes. */ + nodes = 0; j = PointCount-1; + + for (i = 0; i < PointCount; i++) + { + if (POLY_Y(i)<(double) pixelY && POLY_Y(j)>=(double) pixelY || POLY_Y(j)<(double) pixelY && POLY_Y(i)>=(double) pixelY) + { + nodeX[nodes++]=(int) (POLY_X(i)+((pixelY-POLY_Y(i))*(POLY_X(j)-POLY_X(i)))/(POLY_Y(j)-POLY_Y(i))); + } + j = i; + } + + /* Sort the nodes, via a simple "Bubble" sort. */ + i = 0; + while (i < nodes-1) + { + if (nodeX[i]>nodeX[i+1]) + { + swap = nodeX[i]; + nodeX[i] = nodeX[i+1]; + nodeX[i+1] = swap; + if(i) + { + i--; + } + } + else + { + i++; + } + } + + /* Fill the pixels between node pairs. */ + for (i = 0; i < nodes; i+=2) + { + if(nodeX[i] >= IMAGE_RIGHT) + { + break; + } + if(nodeX[i+1] > IMAGE_LEFT) + { + if (nodeX[i] < IMAGE_LEFT) + { + nodeX[i]=IMAGE_LEFT; + } + if(nodeX[i+1] > IMAGE_RIGHT) + { + nodeX[i+1] = IMAGE_RIGHT; + } + LCD_SetTextColor(BackColor); + LCD_DrawLine(pixelY, nodeX[i+1], nodeX[i+1] - nodeX[i], LCD_DIR_HORIZONTAL); + LCD_SetTextColor(TextColor); + PutPixel(pixelY, nodeX[i+1]); + PutPixel(pixelY, nodeX[i]); + /* for (j=nodeX[i]; j<nodeX[i+1]; j++) PutPixel(j,pixelY); */ + } + } + } + + /* draw the edges */ + LCD_SetTextColor(TextColor); +} + +/** + * @brief Reset LCD control line(/CS) and Send Start-Byte + * @param Start_Byte: the Start-Byte to be sent + * @retval None + */ +void LCD_nCS_StartByte(uint8_t Start_Byte) +{ + LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_RESET); + + SPI_I2S_SendData(LCD_SPI, Start_Byte); + + while(SPI_I2S_GetFlagStatus(LCD_SPI, SPI_I2S_FLAG_BSY) != RESET) + { + } +} + + +/** + * @brief Writes index to select the LCD register. + * @param LCD_Reg: address of the selected register. + * @retval None + */ +void LCD_WriteRegIndex(uint8_t LCD_Reg) +{ + /* Reset LCD control line(/CS) and Send Start-Byte */ + LCD_nCS_StartByte(START_BYTE | SET_INDEX); + + /* Write 16-bit Reg Index (High Byte is 0) */ + SPI_I2S_SendData(LCD_SPI, 0x00); + + while(SPI_I2S_GetFlagStatus(LCD_SPI, SPI_I2S_FLAG_BSY) != RESET) + { + } + + SPI_I2S_SendData(LCD_SPI, LCD_Reg); + + while(SPI_I2S_GetFlagStatus(LCD_SPI, SPI_I2S_FLAG_BSY) != RESET) + { + } + + LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_SET); +} + + +/** + * @brief Writes to the selected LCD ILI9320 register. + * @param LCD_Reg: address of the selected register. + * @param LCD_RegValue: value to write to the selected register. + * @retval None + */ +static void LCD_WriteRegILI9320(uint8_t LCD_Reg, uint16_t LCD_RegValue) +{ + /* Write 16-bit Index (then Write Reg) */ + LCD_WriteRegIndex(LCD_Reg); + + /* Write 16-bit Reg */ + /* Reset LCD control line(/CS) and Send Start-Byte */ + LCD_nCS_StartByte(START_BYTE | LCD_WRITE_REG); + + SPI_I2S_SendData(LCD_SPI, LCD_RegValue>>8); + + while(SPI_I2S_GetFlagStatus(LCD_SPI, SPI_I2S_FLAG_BSY) != RESET) + { + } + + SPI_I2S_SendData(LCD_SPI, (LCD_RegValue & 0xFF)); + + while(SPI_I2S_GetFlagStatus(LCD_SPI, SPI_I2S_FLAG_BSY) != RESET) + { + } + + LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_SET); +} + + +/** + * @brief Reads the selected LCD Register. + * @param LCD_Reg: address of the selected register. + * @retval LCD Register Value. + */ +uint16_t LCD_ReadReg(uint8_t LCD_Reg) +{ + uint16_t tmp = 0; + uint8_t i = 0; + + /* LCD_SPI prescaler: 4 */ + LCD_SPI->CR1 &= 0xFFC7; + LCD_SPI->CR1 |= 0x0008; + /* Write 16-bit Index (then Read Reg) */ + LCD_WriteRegIndex(LCD_Reg); + /* Read 16-bit Reg */ + /* Reset LCD control line(/CS) and Send Start-Byte */ + LCD_nCS_StartByte(START_BYTE | LCD_READ_REG); + + for(i = 0; i < 5; i++) + { + SPI_I2S_SendData(LCD_SPI, 0xFF); + while(SPI_I2S_GetFlagStatus(LCD_SPI, SPI_I2S_FLAG_BSY) != RESET) + { + } + /* One byte of invalid dummy data read after the start byte */ + while(SPI_I2S_GetFlagStatus(LCD_SPI, SPI_I2S_FLAG_RXNE) == RESET) + { + } + SPI_I2S_ReceiveData(LCD_SPI); + } + + SPI_I2S_SendData(LCD_SPI, 0xFF); + + /* Read upper byte */ + while(SPI_I2S_GetFlagStatus(LCD_SPI, SPI_I2S_FLAG_BSY) != RESET) + { + } + + /* Read lower byte */ + while(SPI_I2S_GetFlagStatus(LCD_SPI, SPI_I2S_FLAG_RXNE) == RESET) + { + } + tmp = SPI_I2S_ReceiveData(LCD_SPI); + + + SPI_I2S_SendData(LCD_SPI, 0xFF); + while(SPI_I2S_GetFlagStatus(LCD_SPI, SPI_I2S_FLAG_BSY) != RESET) + { + } + + /* Read lower byte */ + while(SPI_I2S_GetFlagStatus(LCD_SPI, SPI_I2S_FLAG_RXNE) == RESET) + { + } + + tmp = ((tmp & 0xFF) << 8) | SPI_I2S_ReceiveData(LCD_SPI); + LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_SET); + + /* LCD_SPI prescaler: 2 */ + LCD_SPI->CR1 &= 0xFFC7; + + return tmp; +} + + +/** + * @brief Prepare to write to the LCD RAM. + * @param None + * @retval None + */ +void LCD_WriteRAM_Prepare(void) +{ + LCD_WriteRegIndex(LCD_REG_34); /* Select GRAM Reg */ + + /* Reset LCD control line(/CS) and Send Start-Byte */ + LCD_nCS_StartByte(START_BYTE | LCD_WRITE_REG); +} + + +/** + * @brief Writes 1 word to the LCD RAM. + * @param RGB_Code: the pixel color in RGB mode (5-6-5). + * @retval None + */ +void LCD_WriteRAMWord(uint16_t RGB_Code) +{ + + LCD_WriteRAM_Prepare(); + + LCD_WriteRAM(RGB_Code); + + LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_SET); +} + + +/** + * @brief Writes to the selected LCD HX8312 register. + * @param LCD_Reg: address of the selected register. + * @param LCD_RegValue: value to write to the selected register. + * @retval None + */ +static void LCD_WriteRegHX8312(uint8_t LCD_Reg, uint8_t LCD_RegValue) +{ + uint16_t tmp = 0; + + LCD_CtrlLinesWrite(LCD_NWR_GPIO_PORT, LCD_NWR_PIN, Bit_RESET); + LCD_CtrlLinesWrite(LCD_RS_GPIO_PORT, LCD_RS_PIN, Bit_RESET); + LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_RESET); + + tmp = LCD_Reg << 8; + tmp |= LCD_RegValue; + + SPI_I2S_SendData(LCD_SPI, tmp); + + while(SPI_I2S_GetFlagStatus(LCD_SPI, SPI_I2S_FLAG_BSY) != RESET) + { + } + + LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_SET); +} + + +/** + * @brief Writes to the selected LCD register. + * @param LCD_Reg: address of the selected register. + * @param LCD_RegValue: value to write to the selected register. + * @retval None + */ +void LCD_WriteReg(uint8_t LCD_Reg, uint16_t LCD_RegValue) +{ + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + LCD_WriteRegILI9320(LCD_Reg, LCD_RegValue); + } + else if(LCDType == LCD_HX8312) + { + LCD_WriteRegHX8312(LCD_Reg, ((uint8_t)LCD_RegValue)); + } +} + + +/** + * @brief Writes to the LCD RAM. + * @param RGB_Code: the pixel color in RGB mode (5-6-5). + * @retval None + */ +void LCD_WriteRAM(uint16_t RGB_Code) +{ + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + SPI_I2S_SendData(LCD_SPI, RGB_Code >> 8); + while(SPI_I2S_GetFlagStatus(LCD_SPI, SPI_I2S_FLAG_BSY) != RESET) + { + } + SPI_I2S_SendData(LCD_SPI, RGB_Code & 0xFF); + while(SPI_I2S_GetFlagStatus(LCD_SPI, SPI_I2S_FLAG_BSY) != RESET) + { + } + } + + if(LCDType == LCD_HX8312) + { + LCD_CtrlLinesWrite(LCD_NWR_GPIO_PORT, LCD_NWR_PIN, Bit_RESET); + LCD_CtrlLinesWrite(LCD_RS_GPIO_PORT, LCD_RS_PIN, Bit_SET); + LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_RESET); + SPI_I2S_SendData(LCD_SPI, RGB_Code); + + while(SPI_I2S_GetFlagStatus(LCD_SPI, SPI_I2S_FLAG_BSY) != RESET) + { + } + + LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_SET); + } +} + + +/** + * @brief Power on the LCD. + * @param None + * @retval None + */ +void LCD_PowerOn(void) +{ + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + /* Power On sequence ---------------------------------------------------------*/ + LCD_WriteReg(LCD_REG_16, 0x0000); /* SAP, BT[3:0], AP, DSTB, SLP, STB */ + LCD_WriteReg(LCD_REG_17, 0x0000); /* DC1[2:0], DC0[2:0], VC[2:0] */ + LCD_WriteReg(LCD_REG_18, 0x0000); /* VREG1OUT voltage */ + LCD_WriteReg(LCD_REG_19, 0x0000); /* VDV[4:0] for VCOM amplitude */ + _delay_(20); /* Dis-charge capacitor power voltage (200ms) */ + LCD_WriteReg(LCD_REG_16, 0x17B0); /* SAP, BT[3:0], AP, DSTB, SLP, STB */ + LCD_WriteReg(LCD_REG_17, 0x0137); /* DC1[2:0], DC0[2:0], VC[2:0] */ + _delay_(5); /* Delay 50 ms */ + LCD_WriteReg(LCD_REG_18, 0x0139); /* VREG1OUT voltage */ + _delay_(5); /* delay 50 ms */ + LCD_WriteReg(LCD_REG_19, 0x1d00); /* VDV[4:0] for VCOM amplitude */ + LCD_WriteReg(LCD_REG_41, 0x0013); /* VCM[4:0] for VCOMH */ + _delay_(5); /* delay 50 ms */ + LCD_WriteReg(LCD_REG_7, 0x0173); /* 262K color and display ON */ + } + else if(LCDType == LCD_HX8312) + { + /* Power On Set */ + LCD_WriteReg(LCD_REG_28, 0x73); + LCD_WriteReg(LCD_REG_36, 0x74); + LCD_WriteReg(LCD_REG_30, 0x01); + LCD_WriteReg(LCD_REG_24, 0xC1); + _delay_(1); /* Delay 10 ms */ + LCD_WriteReg(LCD_REG_24, 0xE1); + LCD_WriteReg(LCD_REG_24, 0xF1); + _delay_(6); /* Delay 60 ms */ + LCD_WriteReg(LCD_REG_24, 0xF5); + _delay_(6); /* Delay 60 ms */ + LCD_WriteReg(LCD_REG_27, 0x09); + _delay_(1); /* Delay 10 ms */ + LCD_WriteReg(LCD_REG_31, 0x11); + LCD_WriteReg(LCD_REG_32, 0x0E); + LCD_WriteReg(LCD_REG_30, 0x81); + _delay_(1); /* Delay 10 ms */ + } +} + + +/** + * @brief Enables the Display. + * @param None + * @retval None + */ +void LCD_DisplayOn(void) +{ + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + /* Display On */ + LCD_WriteReg(LCD_REG_7, 0x0173); /* 262K color and display ON */ + } + else if(LCDType == LCD_HX8312) + { + LCD_WriteReg(LCD_REG_1, 0x50); + LCD_WriteReg(LCD_REG_5, 0x04); + /* Display On */ + LCD_WriteReg(LCD_REG_0, 0x80); + LCD_WriteReg(LCD_REG_59, 0x01); + _delay_(4); /* Delay 40 ms */ + LCD_WriteReg(LCD_REG_0, 0x20); + } +} + + +/** + * @brief Disables the Display. + * @param None + * @retval None + */ +void LCD_DisplayOff(void) +{ + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + /* Display Off */ + LCD_WriteReg(LCD_REG_7, 0x0); + } + else if(LCDType == LCD_HX8312) + { + /* Display Off */ + LCD_WriteReg(LCD_REG_0, 0xA0); + _delay_(4); /* Delay 40 ms */ + LCD_WriteReg(LCD_REG_59, 0x00); + } +} + + +/** + * @brief Configures LCD control lines in Output Push-Pull mode. + * @param None + * @retval None + */ +void LCD_CtrlLinesConfig(void) +{ + GPIO_InitTypeDef GPIO_InitStructure; + + /* Enable GPIO clock */ + RCC_APB2PeriphClockCmd(LCD_NCS_GPIO_CLK | LCD_NWR_GPIO_CLK | LCD_RS_GPIO_CLK, ENABLE); + + /* Configure NCS in Output Push-Pull mode */ + GPIO_InitStructure.GPIO_Pin = LCD_NCS_PIN; + GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; + GPIO_Init(LCD_NCS_GPIO_PORT, &GPIO_InitStructure); + + /* Configure NWR(RNW), RS in Output Push-Pull mode */ + GPIO_InitStructure.GPIO_Pin = LCD_RS_PIN; + GPIO_Init(LCD_RS_GPIO_PORT, &GPIO_InitStructure); + + GPIO_InitStructure.GPIO_Pin = LCD_NWR_PIN; + GPIO_Init(LCD_NWR_GPIO_PORT, &GPIO_InitStructure); + + LCD_CtrlLinesWrite(LCD_NWR_GPIO_PORT, LCD_NWR_PIN, Bit_SET); + LCD_CtrlLinesWrite(LCD_RS_GPIO_PORT, LCD_RS_PIN, Bit_SET); +} + + +/** + * @brief Sets or reset LCD control lines. + * @param GPIOx: where x can be B or D to select the GPIO peripheral. + * @param CtrlPins: the Control line. + * This parameter can be: + * @arg LCD_NCS_PIN: Chip Select pin + * @arg LCD_NWR_PIN: Read/Write Selection pin + * @arg LCD_RS_PIN: Register/RAM Selection pin + * @param BitVal: specifies the value to be written to the selected bit. + * This parameter can be: + * @arg Bit_RESET: to clear the port pin + * @arg Bit_SET: to set the port pin + * @retval None + */ +void LCD_CtrlLinesWrite(GPIO_TypeDef* GPIOx, uint16_t CtrlPins, BitAction BitVal) +{ + /* Set or Reset the control line */ + GPIO_WriteBit(GPIOx, CtrlPins, BitVal); +} + + +/** + * @brief Configures the LCD_SPI interface. + * @param None + * @retval None + */ +void LCD_SPIConfig(void) +{ + SPI_InitTypeDef SPI_InitStructure; + GPIO_InitTypeDef GPIO_InitStructure; + + /* Enable GPIO clock */ + RCC_APB2PeriphClockCmd(LCD_SPI_SCK_GPIO_CLK | LCD_SPI_MISO_GPIO_CLK | LCD_SPI_MOSI_GPIO_CLK, ENABLE); + + /* Enable SPI clock */ + RCC_APB1PeriphClockCmd(LCD_SPI_CLK, ENABLE); + + /* Configure SPI pins: SCK, MISO and MOSI */ + GPIO_InitStructure.GPIO_Pin = LCD_SPI_SCK_PIN; + GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; + GPIO_Init(LCD_SPI_SCK_GPIO_PORT, &GPIO_InitStructure); + + GPIO_InitStructure.GPIO_Pin = LCD_SPI_MISO_PIN; + GPIO_Init(LCD_SPI_MISO_GPIO_PORT, &GPIO_InitStructure); + + GPIO_InitStructure.GPIO_Pin = LCD_SPI_MOSI_PIN; + GPIO_Init(LCD_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure); + + SPI_I2S_DeInit(LCD_SPI); + + /* SPI Config */ + SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; + SPI_InitStructure.SPI_Mode = SPI_Mode_Master; + + if((LCDType == LCD_ILI9320) || (LCDType == LCD_SPFD5408)) + { + SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b; + SPI_InitStructure.SPI_CPOL = SPI_CPOL_High; + SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge; + } + else if(LCDType == LCD_HX8312) + { + SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b; + SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low; + SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge; + } + SPI_InitStructure.SPI_NSS = SPI_NSS_Soft; + SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2; + SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; + + SPI_Init(LCD_SPI, &SPI_InitStructure); + + /* SPI enable */ + SPI_Cmd(LCD_SPI, ENABLE); +} + +/** + * @brief Displays a pixel. + * @param x: pixel x. + * @param y: pixel y. + * @retval None + */ +static void PutPixel(int16_t x, int16_t y) +{ + if(x < 0 || x > 239 || y < 0 || y > 319) + { + return; + } + LCD_DrawLine(x, y, 1, LCD_DIR_HORIZONTAL); +} + +#ifndef USE_Delay +/** + * @brief Inserts a delay time. + * @param nCount: specifies the delay time length. + * @retval None + */ +static void delay(vu32 nCount) +{ + vu32 index = 0; + for(index = (34000 * nCount); index != 0; index--) + { + } +} +#endif /* USE_Delay*/ +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/ diff --git a/tmp/STM32F10x_StdPeriph_Lib_V3.5.0/Utilities/STM32_EVAL/STM32100B_EVAL/stm32100b_eval_lcd.h b/tmp/STM32F10x_StdPeriph_Lib_V3.5.0/Utilities/STM32_EVAL/STM32100B_EVAL/stm32100b_eval_lcd.h new file mode 100644 index 0000000..638c9a0 --- /dev/null +++ b/tmp/STM32F10x_StdPeriph_Lib_V3.5.0/Utilities/STM32_EVAL/STM32100B_EVAL/stm32100b_eval_lcd.h @@ -0,0 +1,393 @@ +/** + ****************************************************************************** + * @file stm32100b_eval_lcd.h + * @author MCD Application Team + * @version V4.5.0 + * @date 07-March-2011 + * @brief This file contains all the functions prototypes for the stm32100b_eval_lcd + * firmware 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, STMICROELECTRONICS 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. + * + * <h2><center>© COPYRIGHT 2011 STMicroelectronics</center></h2> + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32100B_EVAL_LCD_H +#define __STM32100B_EVAL_LCD_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f10x.h" +#include "../Common/fonts.h" + +/** @addtogroup Utilities + * @{ + */ + +/** @addtogroup STM32_EVAL + * @{ + */ + +/** @addtogroup STM32100B_EVAL + * @{ + */ + +/** @addtogroup STM32100B_EVAL_LCD + * @{ + */ + + +/** @defgroup STM32100B_EVAL_LCD_Exported_Types + * @{ + */ +typedef struct +{ + int16_t X; + int16_t Y; +} Point, * pPoint; +/** + * @} + */ + +/** @defgroup STM32100B_EVAL_LCD_Exported_Constants + * @{ + */ + +/** + * @brief Uncomment the line below if you want to use LCD_DrawBMP function to + * display a bitmap picture on the LCD. This function assumes that the bitmap + * file is loaded in the SPI Flash (mounted on STM32100B-EVAL board), however + * user can tailor it according to his application hardware requirement. + */ +/*#define USE_LCD_DrawBMP*/ + +/** + * @brief Uncomment the line below if you want to use user defined Delay function + * (for precise timing), otherwise default _delay_ function defined within + * this driver is used (less precise timing). + */ +/* #define USE_Delay */ + +#ifdef USE_Delay +#include "main.h" + + #define _delay_ Delay /* !< User can provide more timing precise _delay_ function + (with 10ms time base), using SysTick for example */ +#else + #define _delay_ delay /* !< Default _delay_ function with less precise timing */ +#endif + + +/** + * @brief LCD Control pins + */ +#define LCD_NCS_PIN GPIO_Pin_2 +#define LCD_NCS_GPIO_PORT GPIOB +#define LCD_NCS_GPIO_CLK RCC_APB2Periph_GPIOB +#define LCD_NWR_PIN GPIO_Pin_15 +#define LCD_NWR_GPIO_PORT GPIOD +#define LCD_NWR_GPIO_CLK RCC_APB2Periph_GPIOD +#define LCD_RS_PIN GPIO_Pin_7 +#define LCD_RS_GPIO_PORT GPIOD +#define LCD_RS_GPIO_CLK RCC_APB2Periph_GPIOD + +/** + * @brief LCD SPI Interface pins + */ +#define LCD_SPI SPI2 +#define LCD_SPI_CLK RCC_APB1Periph_SPI2 +#define LCD_SPI_SCK_PIN GPIO_Pin_13 +#define LCD_SPI_SCK_GPIO_PORT GPIOB +#define LCD_SPI_SCK_GPIO_CLK RCC_APB2Periph_GPIOB +#define LCD_SPI_MISO_PIN GPIO_Pin_14 +#define LCD_SPI_MISO_GPIO_PORT GPIOB +#define LCD_SPI_MISO_GPIO_CLK RCC_APB2Periph_GPIOB +#define LCD_SPI_MOSI_PIN GPIO_Pin_15 +#define LCD_SPI_MOSI_GPIO_PORT GPIOB +#define LCD_SPI_MOSI_GPIO_CLK RCC_APB2Periph_GPIOB + + +/** + * @brief LCD Registers + */ +#define LCD_REG_0 0x00 +#define LCD_REG_1 0x01 +#define LCD_REG_2 0x02 +#define LCD_REG_3 0x03 +#define LCD_REG_4 0x04 +#define LCD_REG_5 0x05 +#define LCD_REG_6 0x06 +#define LCD_REG_7 0x07 +#define LCD_REG_8 0x08 +#define LCD_REG_9 0x09 +#define LCD_REG_10 0x0A +#define LCD_REG_12 0x0C +#define LCD_REG_13 0x0D +#define LCD_REG_14 0x0E +#define LCD_REG_15 0x0F +#define LCD_REG_16 0x10 +#define LCD_REG_17 0x11 +#define LCD_REG_18 0x12 +#define LCD_REG_19 0x13 +#define LCD_REG_20 0x14 +#define LCD_REG_21 0x15 +#define LCD_REG_22 0x16 +#define LCD_REG_23 0x17 +#define LCD_REG_24 0x18 +#define LCD_REG_25 0x19 +#define LCD_REG_26 0x1A +#define LCD_REG_27 0x1B +#define LCD_REG_28 0x1C +#define LCD_REG_29 0x1D +#define LCD_REG_30 0x1E +#define LCD_REG_31 0x1F +#define LCD_REG_32 0x20 +#define LCD_REG_33 0x21 +#define LCD_REG_34 0x22 +#define LCD_REG_36 0x24 +#define LCD_REG_37 0x25 +#define LCD_REG_40 0x28 +#define LCD_REG_41 0x29 +#define LCD_REG_43 0x2B +#define LCD_REG_45 0x2D +#define LCD_REG_48 0x30 +#define LCD_REG_49 0x31 +#define LCD_REG_50 0x32 +#define LCD_REG_51 0x33 +#define LCD_REG_52 0x34 +#define LCD_REG_53 0x35 +#define LCD_REG_54 0x36 +#define LCD_REG_55 0x37 +#define LCD_REG_56 0x38 +#define LCD_REG_57 0x39 +#define LCD_REG_59 0x3B +#define LCD_REG_60 0x3C +#define LCD_REG_61 0x3D +#define LCD_REG_62 0x3E +#define LCD_REG_63 0x3F +#define LCD_REG_64 0x40 +#define LCD_REG_65 0x41 +#define LCD_REG_66 0x42 +#define LCD_REG_67 0x43 +#define LCD_REG_68 0x44 +#define LCD_REG_69 0x45 +#define LCD_REG_70 0x46 +#define LCD_REG_71 0x47 +#define LCD_REG_72 0x48 +#define LCD_REG_73 0x49 +#define LCD_REG_74 0x4A +#define LCD_REG_75 0x4B +#define LCD_REG_76 0x4C +#define LCD_REG_77 0x4D +#define LCD_REG_78 0x4E +#define LCD_REG_79 0x4F +#define LCD_REG_80 0x50 +#define LCD_REG_81 0x51 +#define LCD_REG_82 0x52 +#define LCD_REG_83 0x53 +#define LCD_REG_96 0x60 +#define LCD_REG_97 0x61 +#define LCD_REG_106 0x6A +#define LCD_REG_118 0x76 +#define LCD_REG_128 0x80 +#define LCD_REG_129 0x81 +#define LCD_REG_130 0x82 +#define LCD_REG_131 0x83 +#define LCD_REG_132 0x84 +#define LCD_REG_133 0x85 +#define LCD_REG_134 0x86 +#define LCD_REG_135 0x87 +#define LCD_REG_136 0x88 +#define LCD_REG_137 0x89 +#define LCD_REG_139 0x8B +#define LCD_REG_140 0x8C +#define LCD_REG_141 0x8D +#define LCD_REG_143 0x8F +#define LCD_REG_144 0x90 +#define LCD_REG_145 0x91 +#define LCD_REG_146 0x92 +#define LCD_REG_147 0x93 +#define LCD_REG_148 0x94 +#define LCD_REG_149 0x95 +#define LCD_REG_150 0x96 +#define LCD_REG_151 0x97 +#define LCD_REG_152 0x98 +#define LCD_REG_153 0x99 +#define LCD_REG_154 0x9A +#define LCD_REG_157 0x9D +#define LCD_REG_192 0xC0 +#define LCD_REG_193 0xC1 +#define LCD_REG_227 0xE3 +#define LCD_REG_229 0xE5 +#define LCD_REG_231 0xE7 +#define LCD_REG_239 0xEF + + +/** + * @brief LCD color + */ +#define LCD_COLOR_WHITE 0xFFFF +#define LCD_COLOR_BLACK 0x0000 +#define LCD_COLOR_GREY 0xF7DE +#define LCD_COLOR_BLUE 0x001F +#define LCD_COLOR_BLUE2 0x051F +#define LCD_COLOR_RED 0xF800 +#define LCD_COLOR_MAGENTA 0xF81F +#define LCD_COLOR_GREEN 0x07E0 +#define LCD_COLOR_CYAN 0x7FFF +#define LCD_COLOR_YELLOW 0xFFE0 + +/** + * @brief LCD Lines depending on the chosen fonts. + */ +#define LCD_LINE_0 LINE(0) +#define LCD_LINE_1 LINE(1) +#define LCD_LINE_2 LINE(2) +#define LCD_LINE_3 LINE(3) +#define LCD_LINE_4 LINE(4) +#define LCD_LINE_5 LINE(5) +#define LCD_LINE_6 LINE(6) +#define LCD_LINE_7 LINE(7) +#define LCD_LINE_8 LINE(8) +#define LCD_LINE_9 LINE(9) +#define LCD_LINE_10 LINE(10) +#define LCD_LINE_11 LINE(11) +#define LCD_LINE_12 LINE(12) +#define LCD_LINE_13 LINE(13) +#define LCD_LINE_14 LINE(14) +#define LCD_LINE_15 LINE(15) +#define LCD_LINE_16 LINE(16) +#define LCD_LINE_17 LINE(17) +#define LCD_LINE_18 LINE(18) +#define LCD_LINE_19 LINE(19) +#define LCD_LINE_20 LINE(20) +#define LCD_LINE_21 LINE(21) +#define LCD_LINE_22 LINE(22) +#define LCD_LINE_23 LINE(23) +#define LCD_LINE_24 LINE(24) +#define LCD_LINE_25 LINE(25) +#define LCD_LINE_26 LINE(26) +#define LCD_LINE_27 LINE(27) +#define LCD_LINE_28 LINE(28) +#define LCD_LINE_29 LINE(29) + + +/** + * @brief LCD default font + */ +#define LCD_DEFAULT_FONT Font16x24 + +/** + * @brief LCD Direction + */ +#define LCD_DIR_HORIZONTAL 0x0000 +#define LCD_DIR_VERTICAL 0x0001 + +/** + * @brief LCD Size (Width and Height) + */ +#define LCD_PIXEL_WIDTH 0x0140 +#define LCD_PIXEL_HEIGHT 0x00F0 + +/** + * @} + */ + +/** @defgroup STM32100B_EVAL_LCD_Exported_Macros + * @{ + */ +#define ASSEMBLE_RGB(R, G, B) ((((R)& 0xF8) << 8) | (((G) & 0xFC) << 3) | (((B) & 0xF8) >> 3)) + +/** + * @} + */ + +/** @defgroup STM32100B_EVAL_LCD_Exported_Functions + * @{ + */ +void LCD_DeInit(void); +void LCD_Setup(void); +void STM32100B_LCD_Init(void); +void LCD_SetColors(__IO uint16_t _TextColor, __IO uint16_t _BackColor); +void LCD_GetColors(__IO uint16_t *_TextColor, __IO uint16_t *_BackColor); +void LCD_SetTextColor(__IO uint16_t Color); +void LCD_SetBackColor(__IO uint16_t Color); +void LCD_ClearLine(uint8_t Line); +void LCD_Clear(uint16_t Color); +void LCD_SetCursor(uint8_t Xpos, uint16_t Ypos); +void LCD_DrawChar(uint8_t Xpos, uint16_t Ypos, const uint16_t *c); +void LCD_DisplayChar(uint8_t Line, uint16_t Column, uint8_t Ascii); +void LCD_SetFont(sFONT *fonts); +sFONT *LCD_GetFont(void); +void LCD_DisplayStringLine(uint8_t Line, uint8_t *ptr); +void LCD_SetDisplayWindow(uint8_t Xpos, uint16_t Ypos, uint8_t Height, uint16_t Width); +void LCD_WindowModeDisable(void); +void LCD_DrawLine(uint8_t Xpos, uint16_t Ypos, uint16_t Length, uint8_t Direction); +void LCD_DrawRect(uint8_t Xpos, uint16_t Ypos, uint8_t Height, uint16_t Width); +void LCD_DrawCircle(uint8_t Xpos, uint16_t Ypos, uint16_t Radius); +void LCD_DrawMonoPict(const uint32_t *Pict); +void LCD_DrawBMP(uint32_t BmpAddress); +void LCD_DrawUniLine(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2); +void LCD_DrawFullRect(uint16_t Xpos, uint16_t Ypos, uint16_t Width, uint16_t Height); +void LCD_DrawFullCircle(uint16_t Xpos, uint16_t Ypos, uint16_t Radius); +void LCD_PolyLine(pPoint Points, uint16_t PointCount); +void LCD_PolyLineRelative(pPoint Points, uint16_t PointCount); +void LCD_ClosedPolyLine(pPoint Points, uint16_t PointCount); +void LCD_ClosedPolyLineRelative(pPoint Points, uint16_t PointCount); +void LCD_FillPolyLine(pPoint Points, uint16_t PointCount); +void LCD_nCS_StartByte(uint8_t Start_Byte); +void LCD_WriteRegIndex(uint8_t LCD_Reg); +void LCD_WriteReg(uint8_t LCD_Reg, uint16_t LCD_RegValue); +void LCD_WriteRAM_Prepare(void); +void LCD_WriteRAMWord(uint16_t RGB_Code); +uint16_t LCD_ReadReg(uint8_t LCD_Reg); +void LCD_WriteRAM(uint16_t RGB_Code); +void LCD_PowerOn(void); +void LCD_DisplayOn(void); +void LCD_DisplayOff(void); + + +void LCD_CtrlLinesConfig(void); +void LCD_CtrlLinesWrite(GPIO_TypeDef* GPIOx, uint16_t CtrlPins, BitAction BitVal); +void LCD_SPIConfig(void); + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32100B_EVAL_LCD_H */ + + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/ |