mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L1/stm32l1xx_hal_lcd.c@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
394:83f921546702 
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



Full URL: https://github.com/mbedmicro/mbed/commit/d5b4d2ab9c47edb4dc5776e7177b0c2263459081/



Initial version of drivers for SAMR21

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 354:e67efb2aab0e 1 /**
mbed_official 354:e67efb2aab0e 2 ******************************************************************************
mbed_official 354:e67efb2aab0e 3 * @file stm32l1xx_hal_lcd.c
mbed_official 354:e67efb2aab0e 4 * @author MCD Application Team
mbed_official 354:e67efb2aab0e 5 * @version V1.0.0
mbed_official 354:e67efb2aab0e 6 * @date 5-September-2014
mbed_official 354:e67efb2aab0e 7 * @brief LCD Controller HAL module driver.
mbed_official 354:e67efb2aab0e 8 * This file provides firmware functions to manage the following
mbed_official 354:e67efb2aab0e 9 * functionalities of the LCD Controller (LCD) peripheral:
mbed_official 354:e67efb2aab0e 10 * + Initialization/de-initialization methods
mbed_official 354:e67efb2aab0e 11 * + I/O operation methods
mbed_official 354:e67efb2aab0e 12 * + Peripheral State methods
mbed_official 354:e67efb2aab0e 13 *
mbed_official 354:e67efb2aab0e 14 @verbatim
mbed_official 354:e67efb2aab0e 15 ==============================================================================
mbed_official 354:e67efb2aab0e 16 ##### How to use this driver #####
mbed_official 354:e67efb2aab0e 17 ==============================================================================
mbed_official 354:e67efb2aab0e 18 [..] The LCD HAL driver can be used as follows:
mbed_official 354:e67efb2aab0e 19
mbed_official 354:e67efb2aab0e 20 (#) Declare a LCD_HandleTypeDef handle structure.
mbed_official 354:e67efb2aab0e 21
mbed_official 354:e67efb2aab0e 22 (#) Initialize the LCD low level resources by implement the HAL_LCD_MspInit() API:
mbed_official 354:e67efb2aab0e 23 (##) Enable the LCDCLK (same as RTCCLK): to configure the RTCCLK/LCDCLK, proceed as follows:
mbed_official 354:e67efb2aab0e 24 (+) Use RCC function HAL_RCCEx_PeriphCLKConfig in indicating RCC_PERIPHCLK_LCD and
mbed_official 354:e67efb2aab0e 25 selected clock source (HSE, LSI or LSE)
mbed_official 354:e67efb2aab0e 26
mbed_official 354:e67efb2aab0e 27 -@- The frequency generator allows you to achieve various LCD frame rates
mbed_official 354:e67efb2aab0e 28 starting from an LCD input clock frequency (LCDCLK) which can vary
mbed_official 354:e67efb2aab0e 29 from 32 kHz up to 1 MHz.
mbed_official 354:e67efb2aab0e 30 (##) LCD pins configuration:
mbed_official 354:e67efb2aab0e 31 (+) Enable the clock for the LCD GPIOs.
mbed_official 354:e67efb2aab0e 32 (+) Configure these LCD pins as alternate function no-pull.
mbed_official 354:e67efb2aab0e 33 (##) Enable the LCD interface clock.
mbed_official 354:e67efb2aab0e 34
mbed_official 354:e67efb2aab0e 35 (#) Program the Prescaler, Divider, Blink mode, Blink Frequency Duty, Bias,
mbed_official 354:e67efb2aab0e 36 Voltage Source, Dead Time, Pulse On Duration and Contrast in the hlcd Init structure.
mbed_official 354:e67efb2aab0e 37
mbed_official 354:e67efb2aab0e 38 (#) Initialize the LCD registers by calling the HAL_LCD_Init() API.
mbed_official 354:e67efb2aab0e 39
mbed_official 354:e67efb2aab0e 40 -@- The HAL_LCD_Init() API configures also the low level Hardware GPIO, CLOCK, ...etc)
mbed_official 354:e67efb2aab0e 41 by calling the custumed HAL_LCD_MspInit() API.
mbed_official 354:e67efb2aab0e 42 -@- After calling the HAL_LCD_Init() the LCD RAM memory is cleared
mbed_official 354:e67efb2aab0e 43
mbed_official 354:e67efb2aab0e 44 (#) Optionally you can update the LCD configuration using these macros:
mbed_official 354:e67efb2aab0e 45 (+) LCD High Drive using the __HAL_LCD_HIGHDRIVER_ENABLE() and __HAL_LCD_HIGHDRIVER_DISABLE() macros
mbed_official 354:e67efb2aab0e 46 (+) LCD Pulse ON Duration using the __HAL_LCD_PULSEONDURATION_CONFIG() macro
mbed_official 354:e67efb2aab0e 47 (+) LCD Dead Time using the __HAL_LCD_DEADTIME_CONFIG() macro
mbed_official 354:e67efb2aab0e 48 (+) The LCD Blink mode and frequency using the __HAL_LCD_BLINK_CONFIG() macro
mbed_official 354:e67efb2aab0e 49 (+) The LCD Contrast using the __HAL_LCD_CONTRAST_CONFIG() macro
mbed_official 354:e67efb2aab0e 50
mbed_official 354:e67efb2aab0e 51 (#) Write to the LCD RAM memory using the HAL_LCD_Write() API, this API can be called
mbed_official 354:e67efb2aab0e 52 more time to update the different LCD RAM registers before calling
mbed_official 354:e67efb2aab0e 53 HAL_LCD_UpdateDisplayRequest() API.
mbed_official 354:e67efb2aab0e 54
mbed_official 354:e67efb2aab0e 55 (#) The HAL_LCD_Clear() API can be used to clear the LCD RAM memory.
mbed_official 354:e67efb2aab0e 56
mbed_official 354:e67efb2aab0e 57 (#) When LCD RAM memory is updated enable the update display request using
mbed_official 354:e67efb2aab0e 58 the HAL_LCD_UpdateDisplayRequest() API.
mbed_official 354:e67efb2aab0e 59
mbed_official 354:e67efb2aab0e 60 [..] LCD and low power modes:
mbed_official 354:e67efb2aab0e 61 (#) The LCD remain active during STOP mode.
mbed_official 354:e67efb2aab0e 62
mbed_official 354:e67efb2aab0e 63 @endverbatim
mbed_official 354:e67efb2aab0e 64 ******************************************************************************
mbed_official 354:e67efb2aab0e 65 * @attention
mbed_official 354:e67efb2aab0e 66 *
mbed_official 354:e67efb2aab0e 67 * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
mbed_official 354:e67efb2aab0e 68 *
mbed_official 354:e67efb2aab0e 69 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 354:e67efb2aab0e 70 * are permitted provided that the following conditions are met:
mbed_official 354:e67efb2aab0e 71 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 354:e67efb2aab0e 72 * this list of conditions and the following disclaimer.
mbed_official 354:e67efb2aab0e 73 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 354:e67efb2aab0e 74 * this list of conditions and the following disclaimer in the documentation
mbed_official 354:e67efb2aab0e 75 * and/or other materials provided with the distribution.
mbed_official 354:e67efb2aab0e 76 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 354:e67efb2aab0e 77 * may be used to endorse or promote products derived from this software
mbed_official 354:e67efb2aab0e 78 * without specific prior written permission.
mbed_official 354:e67efb2aab0e 79 *
mbed_official 354:e67efb2aab0e 80 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 354:e67efb2aab0e 81 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 354:e67efb2aab0e 82 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 354:e67efb2aab0e 83 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 354:e67efb2aab0e 84 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 354:e67efb2aab0e 85 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 354:e67efb2aab0e 86 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 354:e67efb2aab0e 87 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 354:e67efb2aab0e 88 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 354:e67efb2aab0e 89 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 354:e67efb2aab0e 90 *
mbed_official 354:e67efb2aab0e 91 ******************************************************************************
mbed_official 354:e67efb2aab0e 92 */
mbed_official 354:e67efb2aab0e 93
mbed_official 354:e67efb2aab0e 94 /* Includes ------------------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 95 #include "stm32l1xx_hal.h"
mbed_official 354:e67efb2aab0e 96
mbed_official 354:e67efb2aab0e 97 /** @addtogroup STM32L1xx_HAL_Driver
mbed_official 354:e67efb2aab0e 98 * @{
mbed_official 354:e67efb2aab0e 99 */
mbed_official 354:e67efb2aab0e 100
mbed_official 354:e67efb2aab0e 101 #ifdef HAL_LCD_MODULE_ENABLED
mbed_official 354:e67efb2aab0e 102
mbed_official 354:e67efb2aab0e 103 #if defined (STM32L100xB) || defined (STM32L100xBA) || defined (STM32L100xC) ||\
mbed_official 354:e67efb2aab0e 104 defined (STM32L152xB) || defined (STM32L152xBA) || defined (STM32L152xC) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L152xE) ||\
mbed_official 354:e67efb2aab0e 105 defined (STM32L162xC) || defined (STM32L162xCA) || defined (STM32L162xD) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 106
mbed_official 354:e67efb2aab0e 107 /** @defgroup LCD LCD
mbed_official 354:e67efb2aab0e 108 * @brief LCD HAL module driver
mbed_official 354:e67efb2aab0e 109 * @{
mbed_official 354:e67efb2aab0e 110 */
mbed_official 354:e67efb2aab0e 111
mbed_official 354:e67efb2aab0e 112 /* Private typedef -----------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 113 /* Private define ------------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 114 /** @defgroup LCD_Private_Defines LCD Private Defines
mbed_official 354:e67efb2aab0e 115 * @{
mbed_official 354:e67efb2aab0e 116 */
mbed_official 354:e67efb2aab0e 117
mbed_official 354:e67efb2aab0e 118 #define LCD_TIMEOUT_VALUE 1000
mbed_official 354:e67efb2aab0e 119
mbed_official 354:e67efb2aab0e 120 /**
mbed_official 354:e67efb2aab0e 121 * @}
mbed_official 354:e67efb2aab0e 122 */
mbed_official 354:e67efb2aab0e 123
mbed_official 354:e67efb2aab0e 124 /* Private macro -------------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 125 /* Private variables ---------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 126 /* Private function prototypes -----------------------------------------------*/
mbed_official 354:e67efb2aab0e 127 /* Private functions ---------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 128
mbed_official 354:e67efb2aab0e 129 /** @defgroup LCD_Exported_Functions LCD Exported Functions
mbed_official 354:e67efb2aab0e 130 * @{
mbed_official 354:e67efb2aab0e 131 */
mbed_official 354:e67efb2aab0e 132
mbed_official 354:e67efb2aab0e 133 /** @defgroup LCD_Exported_Functions_Group1 Initialization/de-initialization methods
mbed_official 354:e67efb2aab0e 134 * @brief Initialization and Configuration functions
mbed_official 354:e67efb2aab0e 135 *
mbed_official 354:e67efb2aab0e 136 @verbatim
mbed_official 354:e67efb2aab0e 137 ===============================================================================
mbed_official 354:e67efb2aab0e 138 ##### Initialization and Configuration functions #####
mbed_official 354:e67efb2aab0e 139 ===============================================================================
mbed_official 354:e67efb2aab0e 140 [..]
mbed_official 354:e67efb2aab0e 141
mbed_official 354:e67efb2aab0e 142 @endverbatim
mbed_official 354:e67efb2aab0e 143 * @{
mbed_official 354:e67efb2aab0e 144 */
mbed_official 354:e67efb2aab0e 145
mbed_official 354:e67efb2aab0e 146 /**
mbed_official 354:e67efb2aab0e 147 * @brief DeInitializes the LCD peripheral.
mbed_official 354:e67efb2aab0e 148 * @param hlcd: LCD handle
mbed_official 354:e67efb2aab0e 149 * @retval HAL status
mbed_official 354:e67efb2aab0e 150 */
mbed_official 354:e67efb2aab0e 151 HAL_StatusTypeDef HAL_LCD_DeInit(LCD_HandleTypeDef *hlcd)
mbed_official 354:e67efb2aab0e 152 {
mbed_official 354:e67efb2aab0e 153 /* Check the LCD handle allocation */
mbed_official 354:e67efb2aab0e 154 if(hlcd == HAL_NULL)
mbed_official 354:e67efb2aab0e 155 {
mbed_official 354:e67efb2aab0e 156 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 157 }
mbed_official 354:e67efb2aab0e 158
mbed_official 354:e67efb2aab0e 159 /* Check the parameters */
mbed_official 354:e67efb2aab0e 160 assert_param(IS_LCD_ALL_INSTANCE(hlcd->Instance));
mbed_official 354:e67efb2aab0e 161
mbed_official 354:e67efb2aab0e 162 hlcd->State = HAL_LCD_STATE_BUSY;
mbed_official 354:e67efb2aab0e 163
mbed_official 354:e67efb2aab0e 164 /* DeInit the low level hardware */
mbed_official 354:e67efb2aab0e 165 HAL_LCD_MspDeInit(hlcd);
mbed_official 354:e67efb2aab0e 166
mbed_official 354:e67efb2aab0e 167 hlcd->ErrorCode = HAL_LCD_ERROR_NONE;
mbed_official 354:e67efb2aab0e 168 hlcd->State = HAL_LCD_STATE_RESET;
mbed_official 354:e67efb2aab0e 169
mbed_official 354:e67efb2aab0e 170 /* Release Lock */
mbed_official 354:e67efb2aab0e 171 __HAL_UNLOCK(hlcd);
mbed_official 354:e67efb2aab0e 172
mbed_official 354:e67efb2aab0e 173 return HAL_OK;
mbed_official 354:e67efb2aab0e 174 }
mbed_official 354:e67efb2aab0e 175
mbed_official 354:e67efb2aab0e 176 /**
mbed_official 354:e67efb2aab0e 177 * @brief Initializes the LCD peripheral according to the specified parameters
mbed_official 354:e67efb2aab0e 178 * in the LCD_InitStruct.
mbed_official 354:e67efb2aab0e 179 * @note This function can be used only when the LCD is disabled.
mbed_official 354:e67efb2aab0e 180 * @param hlcd: LCD handle
mbed_official 354:e67efb2aab0e 181 * @retval None
mbed_official 354:e67efb2aab0e 182 */
mbed_official 354:e67efb2aab0e 183 HAL_StatusTypeDef HAL_LCD_Init(LCD_HandleTypeDef *hlcd)
mbed_official 354:e67efb2aab0e 184 {
mbed_official 354:e67efb2aab0e 185 uint32_t tickstart = 0x00;
mbed_official 354:e67efb2aab0e 186 uint8_t counter = 0;
mbed_official 354:e67efb2aab0e 187
mbed_official 354:e67efb2aab0e 188 /* Check the LCD handle allocation */
mbed_official 354:e67efb2aab0e 189 if(hlcd == HAL_NULL)
mbed_official 354:e67efb2aab0e 190 {
mbed_official 354:e67efb2aab0e 191 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 192 }
mbed_official 354:e67efb2aab0e 193
mbed_official 354:e67efb2aab0e 194 /* Check function parameters */
mbed_official 354:e67efb2aab0e 195 assert_param(IS_LCD_ALL_INSTANCE(hlcd->Instance));
mbed_official 354:e67efb2aab0e 196 assert_param(IS_LCD_PRESCALER(hlcd->Init.Prescaler));
mbed_official 354:e67efb2aab0e 197 assert_param(IS_LCD_DIVIDER(hlcd->Init.Divider));
mbed_official 354:e67efb2aab0e 198 assert_param(IS_LCD_DUTY(hlcd->Init.Duty));
mbed_official 354:e67efb2aab0e 199 assert_param(IS_LCD_BIAS(hlcd->Init.Bias));
mbed_official 354:e67efb2aab0e 200 assert_param(IS_LCD_VOLTAGE_SOURCE(hlcd->Init.VoltageSource));
mbed_official 354:e67efb2aab0e 201 assert_param(IS_LCD_PULSE_ON_DURATION(hlcd->Init.PulseOnDuration));
mbed_official 354:e67efb2aab0e 202 assert_param(IS_LCD_DEAD_TIME(hlcd->Init.DeadTime));
mbed_official 354:e67efb2aab0e 203 assert_param(IS_LCD_CONTRAST(hlcd->Init.Contrast));
mbed_official 354:e67efb2aab0e 204 assert_param(IS_LCD_BLINK_FREQUENCY(hlcd->Init.BlinkFrequency));
mbed_official 354:e67efb2aab0e 205 assert_param(IS_LCD_BLINK_MODE(hlcd->Init.BlinkMode));
mbed_official 354:e67efb2aab0e 206 assert_param(IS_LCD_MUXSEGMENT(hlcd->Init.MuxSegment));
mbed_official 354:e67efb2aab0e 207
mbed_official 354:e67efb2aab0e 208 if(hlcd->State == HAL_LCD_STATE_RESET)
mbed_official 354:e67efb2aab0e 209 {
mbed_official 354:e67efb2aab0e 210 /* Initialize the low level hardware (MSP) */
mbed_official 354:e67efb2aab0e 211 HAL_LCD_MspInit(hlcd);
mbed_official 354:e67efb2aab0e 212 }
mbed_official 354:e67efb2aab0e 213
mbed_official 354:e67efb2aab0e 214 hlcd->State = HAL_LCD_STATE_BUSY;
mbed_official 354:e67efb2aab0e 215
mbed_official 354:e67efb2aab0e 216 /* Disable the peripheral */
mbed_official 354:e67efb2aab0e 217 __HAL_LCD_DISABLE(hlcd);
mbed_official 354:e67efb2aab0e 218
mbed_official 354:e67efb2aab0e 219 /* Clear the LCD_RAM registers and enable the display request by setting the UDR bit
mbed_official 354:e67efb2aab0e 220 in the LCD_SR register */
mbed_official 354:e67efb2aab0e 221 for(counter = LCD_RAM_REGISTER0; counter <= LCD_RAM_REGISTER15; counter++)
mbed_official 354:e67efb2aab0e 222 {
mbed_official 354:e67efb2aab0e 223 hlcd->Instance->RAM[counter] = 0;
mbed_official 354:e67efb2aab0e 224 }
mbed_official 354:e67efb2aab0e 225 /* Enable the display request */
mbed_official 354:e67efb2aab0e 226 hlcd->Instance->SR |= LCD_SR_UDR;
mbed_official 354:e67efb2aab0e 227
mbed_official 354:e67efb2aab0e 228 /* Configure the LCD Prescaler, Divider, Blink mode and Blink Frequency:
mbed_official 354:e67efb2aab0e 229 Set PS[3:0] bits according to hlcd->Init.Prescaler value
mbed_official 354:e67efb2aab0e 230 Set DIV[3:0] bits according to hlcd->Init.Divider value
mbed_official 354:e67efb2aab0e 231 Set BLINK[1:0] bits according to hlcd->Init.BlinkMode value
mbed_official 354:e67efb2aab0e 232 Set BLINKF[2:0] bits according to hlcd->Init.BlinkFrequency value
mbed_official 354:e67efb2aab0e 233 Set DEAD[2:0] bits according to hlcd->Init.DeadTime value
mbed_official 354:e67efb2aab0e 234 Set PON[2:0] bits according to hlcd->Init.PulseOnDuration value
mbed_official 354:e67efb2aab0e 235 Set CC[2:0] bits according to hlcd->Init.Contrast value */
mbed_official 354:e67efb2aab0e 236 MODIFY_REG(hlcd->Instance->FCR, \
mbed_official 354:e67efb2aab0e 237 (LCD_FCR_PS | LCD_FCR_DIV | LCD_FCR_BLINK| LCD_FCR_BLINKF | \
mbed_official 354:e67efb2aab0e 238 LCD_FCR_DEAD | LCD_FCR_PON | LCD_FCR_CC), \
mbed_official 354:e67efb2aab0e 239 (hlcd->Init.Prescaler | hlcd->Init.Divider | hlcd->Init.BlinkMode | hlcd->Init.BlinkFrequency | \
mbed_official 354:e67efb2aab0e 240 hlcd->Init.DeadTime | hlcd->Init.PulseOnDuration | hlcd->Init.Contrast));
mbed_official 354:e67efb2aab0e 241
mbed_official 354:e67efb2aab0e 242 /* Wait until LCD Frame Control Register Synchronization flag (FCRSF) is set in the LCD_SR register
mbed_official 354:e67efb2aab0e 243 This bit is set by hardware each time the LCD_FCR register is updated in the LCDCLK
mbed_official 354:e67efb2aab0e 244 domain. It is cleared by hardware when writing to the LCD_FCR register.*/
mbed_official 354:e67efb2aab0e 245 LCD_WaitForSynchro(hlcd);
mbed_official 354:e67efb2aab0e 246
mbed_official 354:e67efb2aab0e 247 /* Configure the LCD Duty, Bias, Voltage Source, Dead Time, Pulse On Duration and Contrast:
mbed_official 354:e67efb2aab0e 248 Set DUTY[2:0] bits according to hlcd->Init.Duty value
mbed_official 354:e67efb2aab0e 249 Set BIAS[1:0] bits according to hlcd->Init.Bias value
mbed_official 354:e67efb2aab0e 250 Set VSEL bit according to hlcd->Init.VoltageSource value
mbed_official 354:e67efb2aab0e 251 Set MUX_SEG bit according to hlcd->Init.MuxSegment value */
mbed_official 354:e67efb2aab0e 252 MODIFY_REG(hlcd->Instance->CR, \
mbed_official 354:e67efb2aab0e 253 (LCD_CR_DUTY | LCD_CR_BIAS | LCD_CR_VSEL | LCD_CR_MUX_SEG), \
mbed_official 354:e67efb2aab0e 254 (hlcd->Init.Duty | hlcd->Init.Bias | hlcd->Init.VoltageSource | hlcd->Init.MuxSegment));
mbed_official 354:e67efb2aab0e 255
mbed_official 354:e67efb2aab0e 256 /* Enable the peripheral */
mbed_official 354:e67efb2aab0e 257 __HAL_LCD_ENABLE(hlcd);
mbed_official 354:e67efb2aab0e 258
mbed_official 354:e67efb2aab0e 259 /* Get timeout */
mbed_official 354:e67efb2aab0e 260 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 261
mbed_official 354:e67efb2aab0e 262 /* Wait Until the LCD is enabled */
mbed_official 354:e67efb2aab0e 263 while(__HAL_LCD_GET_FLAG(hlcd, LCD_FLAG_ENS) == RESET)
mbed_official 354:e67efb2aab0e 264 {
mbed_official 354:e67efb2aab0e 265 if((HAL_GetTick() - tickstart ) > LCD_TIMEOUT_VALUE)
mbed_official 354:e67efb2aab0e 266 {
mbed_official 354:e67efb2aab0e 267 hlcd->ErrorCode = HAL_LCD_ERROR_ENS;
mbed_official 354:e67efb2aab0e 268 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 269 }
mbed_official 354:e67efb2aab0e 270 }
mbed_official 354:e67efb2aab0e 271
mbed_official 354:e67efb2aab0e 272 /* Get timeout */
mbed_official 354:e67efb2aab0e 273 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 274
mbed_official 354:e67efb2aab0e 275 /*!< Wait Until the LCD Booster is ready */
mbed_official 354:e67efb2aab0e 276 while(__HAL_LCD_GET_FLAG(hlcd, LCD_FLAG_RDY) == RESET)
mbed_official 354:e67efb2aab0e 277 {
mbed_official 354:e67efb2aab0e 278 if((HAL_GetTick() - tickstart ) > LCD_TIMEOUT_VALUE)
mbed_official 354:e67efb2aab0e 279 {
mbed_official 354:e67efb2aab0e 280 hlcd->ErrorCode = HAL_LCD_ERROR_RDY;
mbed_official 354:e67efb2aab0e 281 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 282 }
mbed_official 354:e67efb2aab0e 283 }
mbed_official 354:e67efb2aab0e 284
mbed_official 354:e67efb2aab0e 285 /* Initialize the LCD state */
mbed_official 354:e67efb2aab0e 286 hlcd->ErrorCode = HAL_LCD_ERROR_NONE;
mbed_official 354:e67efb2aab0e 287 hlcd->State= HAL_LCD_STATE_READY;
mbed_official 354:e67efb2aab0e 288
mbed_official 354:e67efb2aab0e 289 return HAL_OK;
mbed_official 354:e67efb2aab0e 290 }
mbed_official 354:e67efb2aab0e 291
mbed_official 354:e67efb2aab0e 292 /**
mbed_official 354:e67efb2aab0e 293 * @brief LCD MSP DeInit.
mbed_official 354:e67efb2aab0e 294 * @param hlcd: LCD handle
mbed_official 354:e67efb2aab0e 295 * @retval None
mbed_official 354:e67efb2aab0e 296 */
mbed_official 354:e67efb2aab0e 297 __weak void HAL_LCD_MspDeInit(LCD_HandleTypeDef *hlcd)
mbed_official 354:e67efb2aab0e 298 {
mbed_official 354:e67efb2aab0e 299 /* NOTE: This function Should not be modified, when the callback is needed,
mbed_official 354:e67efb2aab0e 300 the HAL_LCD_MspDeInit could be implemented in the user file
mbed_official 354:e67efb2aab0e 301 */
mbed_official 354:e67efb2aab0e 302 }
mbed_official 354:e67efb2aab0e 303
mbed_official 354:e67efb2aab0e 304 /**
mbed_official 354:e67efb2aab0e 305 * @brief LCD MSP Init.
mbed_official 354:e67efb2aab0e 306 * @param hlcd: LCD handle
mbed_official 354:e67efb2aab0e 307 * @retval None
mbed_official 354:e67efb2aab0e 308 */
mbed_official 354:e67efb2aab0e 309 __weak void HAL_LCD_MspInit(LCD_HandleTypeDef *hlcd)
mbed_official 354:e67efb2aab0e 310 {
mbed_official 354:e67efb2aab0e 311 /* NOTE: This function Should not be modified, when the callback is needed,
mbed_official 354:e67efb2aab0e 312 the HAL_LCD_MspInit could be implemented in the user file
mbed_official 354:e67efb2aab0e 313 */
mbed_official 354:e67efb2aab0e 314 }
mbed_official 354:e67efb2aab0e 315
mbed_official 354:e67efb2aab0e 316 /**
mbed_official 354:e67efb2aab0e 317 * @}
mbed_official 354:e67efb2aab0e 318 */
mbed_official 354:e67efb2aab0e 319
mbed_official 354:e67efb2aab0e 320 /** @defgroup LCD_Exported_Functions_Group2 IO operation methods
mbed_official 354:e67efb2aab0e 321 * @brief LCD RAM functions
mbed_official 354:e67efb2aab0e 322 *
mbed_official 354:e67efb2aab0e 323 @verbatim
mbed_official 354:e67efb2aab0e 324 ===============================================================================
mbed_official 354:e67efb2aab0e 325 ##### IO operation functions #####
mbed_official 354:e67efb2aab0e 326 ===============================================================================
mbed_official 354:e67efb2aab0e 327 [..] Using its double buffer memory the LCD controller ensures the coherency of the
mbed_official 354:e67efb2aab0e 328 displayed information without having to use interrupts to control LCD_RAM
mbed_official 354:e67efb2aab0e 329 modification.
mbed_official 354:e67efb2aab0e 330 The application software can access the first buffer level (LCD_RAM) through
mbed_official 354:e67efb2aab0e 331 the APB interface. Once it has modified the LCD_RAM using the HAL_LCD_Write() API,
mbed_official 354:e67efb2aab0e 332 it sets the UDR flag in the LCD_SR register using the HAL_LCD_UpdateDisplayRequest() API.
mbed_official 354:e67efb2aab0e 333 This UDR flag (update display request) requests the updated information to be
mbed_official 354:e67efb2aab0e 334 moved into the second buffer level (LCD_DISPLAY).
mbed_official 354:e67efb2aab0e 335 This operation is done synchronously with the frame (at the beginning of the
mbed_official 354:e67efb2aab0e 336 next frame), until the update is completed, the LCD_RAM is write protected and
mbed_official 354:e67efb2aab0e 337 the UDR flag stays high.
mbed_official 354:e67efb2aab0e 338 Once the update is completed another flag (UDD - Update Display Done) is set and
mbed_official 354:e67efb2aab0e 339 generates an interrupt if the UDDIE bit in the LCD_FCR register is set.
mbed_official 354:e67efb2aab0e 340 The time it takes to update LCD_DISPLAY is, in the worst case, one odd and one
mbed_official 354:e67efb2aab0e 341 even frame.
mbed_official 354:e67efb2aab0e 342 The update will not occur (UDR = 1 and UDD = 0) until the display is
mbed_official 354:e67efb2aab0e 343 enabled (LCDEN = 1).
mbed_official 354:e67efb2aab0e 344
mbed_official 354:e67efb2aab0e 345 @endverbatim
mbed_official 354:e67efb2aab0e 346 * @{
mbed_official 354:e67efb2aab0e 347 */
mbed_official 354:e67efb2aab0e 348
mbed_official 354:e67efb2aab0e 349 /**
mbed_official 354:e67efb2aab0e 350 * @brief Writes a word in the specific LCD RAM.
mbed_official 354:e67efb2aab0e 351 * @param hlcd: LCD handle
mbed_official 354:e67efb2aab0e 352 * @param RAMRegisterIndex: specifies the LCD RAM Register.
mbed_official 354:e67efb2aab0e 353 * This parameter can be one of the following values:
mbed_official 354:e67efb2aab0e 354 * @arg LCD_RAM_REGISTER0: LCD RAM Register 0
mbed_official 354:e67efb2aab0e 355 * @arg LCD_RAM_REGISTER1: LCD RAM Register 1
mbed_official 354:e67efb2aab0e 356 * @arg LCD_RAM_REGISTER2: LCD RAM Register 2
mbed_official 354:e67efb2aab0e 357 * @arg LCD_RAM_REGISTER3: LCD RAM Register 3
mbed_official 354:e67efb2aab0e 358 * @arg LCD_RAM_REGISTER4: LCD RAM Register 4
mbed_official 354:e67efb2aab0e 359 * @arg LCD_RAM_REGISTER5: LCD RAM Register 5
mbed_official 354:e67efb2aab0e 360 * @arg LCD_RAM_REGISTER6: LCD RAM Register 6
mbed_official 354:e67efb2aab0e 361 * @arg LCD_RAM_REGISTER7: LCD RAM Register 7
mbed_official 354:e67efb2aab0e 362 * @arg LCD_RAM_REGISTER8: LCD RAM Register 8
mbed_official 354:e67efb2aab0e 363 * @arg LCD_RAM_REGISTER9: LCD RAM Register 9
mbed_official 354:e67efb2aab0e 364 * @arg LCD_RAM_REGISTER10: LCD RAM Register 10
mbed_official 354:e67efb2aab0e 365 * @arg LCD_RAM_REGISTER11: LCD RAM Register 11
mbed_official 354:e67efb2aab0e 366 * @arg LCD_RAM_REGISTER12: LCD RAM Register 12
mbed_official 354:e67efb2aab0e 367 * @arg LCD_RAM_REGISTER13: LCD RAM Register 13
mbed_official 354:e67efb2aab0e 368 * @arg LCD_RAM_REGISTER14: LCD RAM Register 14
mbed_official 354:e67efb2aab0e 369 * @arg LCD_RAM_REGISTER15: LCD RAM Register 15
mbed_official 354:e67efb2aab0e 370 * @param RAMRegisterMask: specifies the LCD RAM Register Data Mask.
mbed_official 354:e67efb2aab0e 371 * @param Data: specifies LCD Data Value to be written.
mbed_official 354:e67efb2aab0e 372 * @retval None
mbed_official 354:e67efb2aab0e 373 */
mbed_official 354:e67efb2aab0e 374 HAL_StatusTypeDef HAL_LCD_Write(LCD_HandleTypeDef *hlcd, uint32_t RAMRegisterIndex, uint32_t RAMRegisterMask, uint32_t Data)
mbed_official 354:e67efb2aab0e 375 {
mbed_official 354:e67efb2aab0e 376 uint32_t tickstart = 0x00;
mbed_official 354:e67efb2aab0e 377
mbed_official 354:e67efb2aab0e 378 if((hlcd->State == HAL_LCD_STATE_READY) || (hlcd->State == HAL_LCD_STATE_BUSY))
mbed_official 354:e67efb2aab0e 379 {
mbed_official 354:e67efb2aab0e 380 /* Check the parameters */
mbed_official 354:e67efb2aab0e 381 assert_param(IS_LCD_RAM_REGISTER(RAMRegisterIndex));
mbed_official 354:e67efb2aab0e 382
mbed_official 354:e67efb2aab0e 383 if(hlcd->State == HAL_LCD_STATE_READY)
mbed_official 354:e67efb2aab0e 384 {
mbed_official 354:e67efb2aab0e 385 /* Process Locked */
mbed_official 354:e67efb2aab0e 386 __HAL_LOCK(hlcd);
mbed_official 354:e67efb2aab0e 387 hlcd->State = HAL_LCD_STATE_BUSY;
mbed_official 354:e67efb2aab0e 388
mbed_official 354:e67efb2aab0e 389 /* Get timeout */
mbed_official 354:e67efb2aab0e 390 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 391
mbed_official 354:e67efb2aab0e 392 /*!< Wait Until the LCD is ready */
mbed_official 354:e67efb2aab0e 393 while(__HAL_LCD_GET_FLAG(hlcd, LCD_FLAG_UDR) != RESET)
mbed_official 354:e67efb2aab0e 394 {
mbed_official 354:e67efb2aab0e 395 if((HAL_GetTick() - tickstart ) > LCD_TIMEOUT_VALUE)
mbed_official 354:e67efb2aab0e 396 {
mbed_official 354:e67efb2aab0e 397 hlcd->ErrorCode = HAL_LCD_ERROR_UDR;
mbed_official 354:e67efb2aab0e 398
mbed_official 354:e67efb2aab0e 399 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 400 __HAL_UNLOCK(hlcd);
mbed_official 354:e67efb2aab0e 401
mbed_official 354:e67efb2aab0e 402 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 403 }
mbed_official 354:e67efb2aab0e 404 }
mbed_official 354:e67efb2aab0e 405 }
mbed_official 354:e67efb2aab0e 406
mbed_official 354:e67efb2aab0e 407 /* Copy the new Data bytes to LCD RAM register */
mbed_official 354:e67efb2aab0e 408 MODIFY_REG(hlcd->Instance->RAM[RAMRegisterIndex], ~(RAMRegisterMask), Data);
mbed_official 354:e67efb2aab0e 409
mbed_official 354:e67efb2aab0e 410 return HAL_OK;
mbed_official 354:e67efb2aab0e 411 }
mbed_official 354:e67efb2aab0e 412 else
mbed_official 354:e67efb2aab0e 413 {
mbed_official 354:e67efb2aab0e 414 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 415 }
mbed_official 354:e67efb2aab0e 416 }
mbed_official 354:e67efb2aab0e 417
mbed_official 354:e67efb2aab0e 418 /**
mbed_official 354:e67efb2aab0e 419 * @brief Clears the LCD RAM registers.
mbed_official 354:e67efb2aab0e 420 * @param hlcd: LCD handle
mbed_official 354:e67efb2aab0e 421 * @retval None
mbed_official 354:e67efb2aab0e 422 */
mbed_official 354:e67efb2aab0e 423 HAL_StatusTypeDef HAL_LCD_Clear(LCD_HandleTypeDef *hlcd)
mbed_official 354:e67efb2aab0e 424 {
mbed_official 354:e67efb2aab0e 425 uint32_t tickstart = 0x00;
mbed_official 354:e67efb2aab0e 426 uint32_t counter = 0;
mbed_official 354:e67efb2aab0e 427
mbed_official 354:e67efb2aab0e 428 if((hlcd->State == HAL_LCD_STATE_READY) || (hlcd->State == HAL_LCD_STATE_BUSY))
mbed_official 354:e67efb2aab0e 429 {
mbed_official 354:e67efb2aab0e 430 /* Process Locked */
mbed_official 354:e67efb2aab0e 431 __HAL_LOCK(hlcd);
mbed_official 354:e67efb2aab0e 432
mbed_official 354:e67efb2aab0e 433 hlcd->State = HAL_LCD_STATE_BUSY;
mbed_official 354:e67efb2aab0e 434
mbed_official 354:e67efb2aab0e 435 /* Get timeout */
mbed_official 354:e67efb2aab0e 436 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 437
mbed_official 354:e67efb2aab0e 438 /*!< Wait Until the LCD is ready */
mbed_official 354:e67efb2aab0e 439 while(__HAL_LCD_GET_FLAG(hlcd, LCD_FLAG_UDR) != RESET)
mbed_official 354:e67efb2aab0e 440 {
mbed_official 354:e67efb2aab0e 441 if((HAL_GetTick() - tickstart ) > LCD_TIMEOUT_VALUE)
mbed_official 354:e67efb2aab0e 442 {
mbed_official 354:e67efb2aab0e 443 hlcd->ErrorCode = HAL_LCD_ERROR_UDR;
mbed_official 354:e67efb2aab0e 444
mbed_official 354:e67efb2aab0e 445 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 446 __HAL_UNLOCK(hlcd);
mbed_official 354:e67efb2aab0e 447
mbed_official 354:e67efb2aab0e 448 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 449 }
mbed_official 354:e67efb2aab0e 450 }
mbed_official 354:e67efb2aab0e 451 /* Clear the LCD_RAM registers */
mbed_official 354:e67efb2aab0e 452 for(counter = LCD_RAM_REGISTER0; counter <= LCD_RAM_REGISTER15; counter++)
mbed_official 354:e67efb2aab0e 453 {
mbed_official 354:e67efb2aab0e 454 hlcd->Instance->RAM[counter] = 0;
mbed_official 354:e67efb2aab0e 455 }
mbed_official 354:e67efb2aab0e 456
mbed_official 354:e67efb2aab0e 457 /* Update the LCD display */
mbed_official 354:e67efb2aab0e 458 HAL_LCD_UpdateDisplayRequest(hlcd);
mbed_official 354:e67efb2aab0e 459
mbed_official 354:e67efb2aab0e 460 return HAL_OK;
mbed_official 354:e67efb2aab0e 461 }
mbed_official 354:e67efb2aab0e 462 else
mbed_official 354:e67efb2aab0e 463 {
mbed_official 354:e67efb2aab0e 464 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 465 }
mbed_official 354:e67efb2aab0e 466 }
mbed_official 354:e67efb2aab0e 467
mbed_official 354:e67efb2aab0e 468 /**
mbed_official 354:e67efb2aab0e 469 * @brief Enables the Update Display Request.
mbed_official 354:e67efb2aab0e 470 * @param hlcd: LCD handle
mbed_official 354:e67efb2aab0e 471 * @note Each time software modifies the LCD_RAM it must set the UDR bit to
mbed_official 354:e67efb2aab0e 472 * transfer the updated data to the second level buffer.
mbed_official 354:e67efb2aab0e 473 * The UDR bit stays set until the end of the update and during this
mbed_official 354:e67efb2aab0e 474 * time the LCD_RAM is write protected.
mbed_official 354:e67efb2aab0e 475 * @note When the display is disabled, the update is performed for all
mbed_official 354:e67efb2aab0e 476 * LCD_DISPLAY locations.
mbed_official 354:e67efb2aab0e 477 * When the display is enabled, the update is performed only for locations
mbed_official 354:e67efb2aab0e 478 * for which commons are active (depending on DUTY). For example if
mbed_official 354:e67efb2aab0e 479 * DUTY = 1/2, only the LCD_DISPLAY of COM0 and COM1 will be updated.
mbed_official 354:e67efb2aab0e 480 * @retval None
mbed_official 354:e67efb2aab0e 481 */
mbed_official 354:e67efb2aab0e 482 HAL_StatusTypeDef HAL_LCD_UpdateDisplayRequest(LCD_HandleTypeDef *hlcd)
mbed_official 354:e67efb2aab0e 483 {
mbed_official 354:e67efb2aab0e 484 uint32_t tickstart = 0x00;
mbed_official 354:e67efb2aab0e 485
mbed_official 354:e67efb2aab0e 486 /* Clear the Update Display Done flag before starting the update display request */
mbed_official 354:e67efb2aab0e 487 __HAL_LCD_CLEAR_FLAG(hlcd, LCD_FLAG_UDD);
mbed_official 354:e67efb2aab0e 488
mbed_official 354:e67efb2aab0e 489 /* Enable the display request */
mbed_official 354:e67efb2aab0e 490 hlcd->Instance->SR |= LCD_SR_UDR;
mbed_official 354:e67efb2aab0e 491
mbed_official 354:e67efb2aab0e 492 /* Get timeout */
mbed_official 354:e67efb2aab0e 493 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 494
mbed_official 354:e67efb2aab0e 495 /*!< Wait Until the LCD display is done */
mbed_official 354:e67efb2aab0e 496 while(__HAL_LCD_GET_FLAG(hlcd, LCD_FLAG_UDD) == RESET)
mbed_official 354:e67efb2aab0e 497 {
mbed_official 354:e67efb2aab0e 498 if((HAL_GetTick() - tickstart ) > LCD_TIMEOUT_VALUE)
mbed_official 354:e67efb2aab0e 499 {
mbed_official 354:e67efb2aab0e 500 hlcd->ErrorCode = HAL_LCD_ERROR_UDD;
mbed_official 354:e67efb2aab0e 501
mbed_official 354:e67efb2aab0e 502 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 503 __HAL_UNLOCK(hlcd);
mbed_official 354:e67efb2aab0e 504
mbed_official 354:e67efb2aab0e 505 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 506 }
mbed_official 354:e67efb2aab0e 507 }
mbed_official 354:e67efb2aab0e 508
mbed_official 354:e67efb2aab0e 509 hlcd->State = HAL_LCD_STATE_READY;
mbed_official 354:e67efb2aab0e 510
mbed_official 354:e67efb2aab0e 511 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 512 __HAL_UNLOCK(hlcd);
mbed_official 354:e67efb2aab0e 513
mbed_official 354:e67efb2aab0e 514 return HAL_OK;
mbed_official 354:e67efb2aab0e 515 }
mbed_official 354:e67efb2aab0e 516
mbed_official 354:e67efb2aab0e 517 /**
mbed_official 354:e67efb2aab0e 518 * @}
mbed_official 354:e67efb2aab0e 519 */
mbed_official 354:e67efb2aab0e 520
mbed_official 354:e67efb2aab0e 521 /** @defgroup LCD_Exported_Functions_Group3 Peripheral State methods
mbed_official 354:e67efb2aab0e 522 * @brief LCD State functions
mbed_official 354:e67efb2aab0e 523 *
mbed_official 354:e67efb2aab0e 524 @verbatim
mbed_official 354:e67efb2aab0e 525 ===============================================================================
mbed_official 354:e67efb2aab0e 526 ##### Peripheral State functions #####
mbed_official 354:e67efb2aab0e 527 ===============================================================================
mbed_official 354:e67efb2aab0e 528 [..]
mbed_official 354:e67efb2aab0e 529 This subsection provides a set of functions allowing to control the LCD:
mbed_official 354:e67efb2aab0e 530 (+) HAL_LCD_GetState() API can be helpful to check in run-time the state of the LCD peripheral State.
mbed_official 354:e67efb2aab0e 531 (+) HAL_LCD_GetError() API to return the LCD error code.
mbed_official 354:e67efb2aab0e 532 @endverbatim
mbed_official 354:e67efb2aab0e 533 * @{
mbed_official 354:e67efb2aab0e 534 */
mbed_official 354:e67efb2aab0e 535
mbed_official 354:e67efb2aab0e 536 /**
mbed_official 354:e67efb2aab0e 537 * @brief Returns the LCD state.
mbed_official 354:e67efb2aab0e 538 * @param hlcd: LCD handle
mbed_official 354:e67efb2aab0e 539 * @retval HAL state
mbed_official 354:e67efb2aab0e 540 */
mbed_official 354:e67efb2aab0e 541 HAL_LCD_StateTypeDef HAL_LCD_GetState(LCD_HandleTypeDef *hlcd)
mbed_official 354:e67efb2aab0e 542 {
mbed_official 354:e67efb2aab0e 543 return hlcd->State;
mbed_official 354:e67efb2aab0e 544 }
mbed_official 354:e67efb2aab0e 545
mbed_official 354:e67efb2aab0e 546 /**
mbed_official 354:e67efb2aab0e 547 * @brief Return the LCD error code
mbed_official 354:e67efb2aab0e 548 * @param hlcd: LCD handle
mbed_official 354:e67efb2aab0e 549 * @retval LCD Error Code
mbed_official 354:e67efb2aab0e 550 */
mbed_official 354:e67efb2aab0e 551 uint32_t HAL_LCD_GetError(LCD_HandleTypeDef *hlcd)
mbed_official 354:e67efb2aab0e 552 {
mbed_official 354:e67efb2aab0e 553 return hlcd->ErrorCode;
mbed_official 354:e67efb2aab0e 554 }
mbed_official 354:e67efb2aab0e 555
mbed_official 354:e67efb2aab0e 556 /**
mbed_official 354:e67efb2aab0e 557 * @}
mbed_official 354:e67efb2aab0e 558 */
mbed_official 354:e67efb2aab0e 559
mbed_official 354:e67efb2aab0e 560 /**
mbed_official 354:e67efb2aab0e 561 * @}
mbed_official 354:e67efb2aab0e 562 */
mbed_official 354:e67efb2aab0e 563
mbed_official 354:e67efb2aab0e 564 /** @defgroup LCD_Private_Functions LCD Private Functions
mbed_official 354:e67efb2aab0e 565 * @{
mbed_official 354:e67efb2aab0e 566 */
mbed_official 354:e67efb2aab0e 567
mbed_official 354:e67efb2aab0e 568 /**
mbed_official 354:e67efb2aab0e 569 * @brief Waits until the LCD FCR register is synchronized in the LCDCLK domain.
mbed_official 354:e67efb2aab0e 570 * This function must be called after any write operation to LCD_FCR register.
mbed_official 354:e67efb2aab0e 571 * @retval None
mbed_official 354:e67efb2aab0e 572 */
mbed_official 354:e67efb2aab0e 573 HAL_StatusTypeDef LCD_WaitForSynchro(LCD_HandleTypeDef *hlcd)
mbed_official 354:e67efb2aab0e 574 {
mbed_official 354:e67efb2aab0e 575 uint32_t tickstart = 0x00;
mbed_official 354:e67efb2aab0e 576
mbed_official 354:e67efb2aab0e 577 /* Get timeout */
mbed_official 354:e67efb2aab0e 578 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 579
mbed_official 354:e67efb2aab0e 580 /* Loop until FCRSF flag is set */
mbed_official 354:e67efb2aab0e 581 while(__HAL_LCD_GET_FLAG(hlcd, LCD_FLAG_FCRSF) == RESET)
mbed_official 354:e67efb2aab0e 582 {
mbed_official 354:e67efb2aab0e 583 if((HAL_GetTick() - tickstart ) > LCD_TIMEOUT_VALUE)
mbed_official 354:e67efb2aab0e 584 {
mbed_official 354:e67efb2aab0e 585 hlcd->ErrorCode = HAL_LCD_ERROR_FCRSF;
mbed_official 354:e67efb2aab0e 586 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 587 }
mbed_official 354:e67efb2aab0e 588 }
mbed_official 354:e67efb2aab0e 589
mbed_official 354:e67efb2aab0e 590 return HAL_OK;
mbed_official 354:e67efb2aab0e 591 }
mbed_official 354:e67efb2aab0e 592
mbed_official 354:e67efb2aab0e 593 /**
mbed_official 354:e67efb2aab0e 594 * @}
mbed_official 354:e67efb2aab0e 595 */
mbed_official 354:e67efb2aab0e 596
mbed_official 354:e67efb2aab0e 597 /**
mbed_official 354:e67efb2aab0e 598 * @}
mbed_official 354:e67efb2aab0e 599 */
mbed_official 354:e67efb2aab0e 600
mbed_official 354:e67efb2aab0e 601 #endif /* STM32L100xB || STM32L100xBA || STM32L100xC ||... || STM32L162xD || STM32L162xE */
mbed_official 354:e67efb2aab0e 602
mbed_official 354:e67efb2aab0e 603 #endif /* HAL_LCD_MODULE_ENABLED */
mbed_official 354:e67efb2aab0e 604
mbed_official 354:e67efb2aab0e 605 /**
mbed_official 354:e67efb2aab0e 606 * @}
mbed_official 354:e67efb2aab0e 607 */
mbed_official 354:e67efb2aab0e 608
mbed_official 354:e67efb2aab0e 609 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
mbed_official 354:e67efb2aab0e 610