STM32F4xx_Nucleo BSP User Manual
|
stm32f4xx_nucleo.c
Go to the documentation of this file.
00001 /** 00002 ****************************************************************************** 00003 * @file stm32f4xx_nucleo.c 00004 * @author MCD Application Team 00005 * @version V1.2.4 00006 * @date 12-January-2016 00007 * @brief This file provides set of firmware functions to manage: 00008 * - LEDs and push-button available on STM32F4XX-Nucleo Kit 00009 * from STMicroelectronics 00010 * - LCD, joystick and microSD available on Adafruit 1.8" TFT LCD 00011 * shield (reference ID 802) 00012 ****************************************************************************** 00013 * @attention 00014 * 00015 * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2> 00016 * 00017 * Redistribution and use in source and binary forms, with or without modification, 00018 * are permitted provided that the following conditions are met: 00019 * 1. Redistributions of source code must retain the above copyright notice, 00020 * this list of conditions and the following disclaimer. 00021 * 2. Redistributions in binary form must reproduce the above copyright notice, 00022 * this list of conditions and the following disclaimer in the documentation 00023 * and/or other materials provided with the distribution. 00024 * 3. Neither the name of STMicroelectronics nor the names of its contributors 00025 * may be used to endorse or promote products derived from this software 00026 * without specific prior written permission. 00027 * 00028 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 00029 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 00030 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 00031 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 00032 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 00033 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 00034 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 00035 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 00036 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 00037 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 00038 * 00039 ****************************************************************************** 00040 */ 00041 00042 /* Includes ------------------------------------------------------------------*/ 00043 #include "stm32f4xx_nucleo.h" 00044 00045 /** @defgroup BSP BSP 00046 * @{ 00047 */ 00048 00049 /** @defgroup STM32F4XX_NUCLEO STM32F4XX NUCLEO 00050 * @{ 00051 */ 00052 00053 /** @defgroup STM32F4XX_NUCLEO_LOW_LEVEL STM32F4XX NUCLEO LOW LEVEL 00054 * @brief This file provides set of firmware functions to manage Leds and push-button 00055 * available on STM32F4xx-Nucleo Kit from STMicroelectronics. 00056 * @{ 00057 */ 00058 00059 /** @defgroup STM32F4XX_NUCLEO_LOW_LEVEL_Private_TypesDefinitions STM32F4XX NUCLEO LOW LEVEL Private TypesDefinitions 00060 * @{ 00061 */ 00062 /** 00063 * @} 00064 */ 00065 00066 00067 /** @defgroup STM32F4XX_NUCLEO_LOW_LEVEL_Private_Defines STM32F4XX NUCLEO LOW LEVEL Private Defines 00068 * @{ 00069 */ 00070 00071 /** 00072 * @brief STM32F4xx NUCLEO BSP Driver version number V1.2.4 00073 */ 00074 #define __STM32F4xx_NUCLEO_BSP_VERSION_MAIN (0x01) /*!< [31:24] main version */ 00075 #define __STM32F4xx_NUCLEO_BSP_VERSION_SUB1 (0x02) /*!< [23:16] sub1 version */ 00076 #define __STM32F4xx_NUCLEO_BSP_VERSION_SUB2 (0x04) /*!< [15:8] sub2 version */ 00077 #define __STM32F4xx_NUCLEO_BSP_VERSION_RC (0x00) /*!< [7:0] release candidate */ 00078 #define __STM32F4xx_NUCLEO_BSP_VERSION ((__STM32F4xx_NUCLEO_BSP_VERSION_MAIN << 24)\ 00079 |(__STM32F4xx_NUCLEO_BSP_VERSION_SUB1 << 16)\ 00080 |(__STM32F4xx_NUCLEO_BSP_VERSION_SUB2 << 8 )\ 00081 |(__STM32F4xx_NUCLEO_BSP_VERSION_RC)) 00082 00083 /** 00084 * @brief LINK SD Card 00085 */ 00086 #define SD_DUMMY_BYTE 0xFF 00087 #define SD_NO_RESPONSE_EXPECTED 0x80 00088 00089 /** 00090 * @} 00091 */ 00092 00093 /** @defgroup STM32F4XX_NUCLEO_LOW_LEVEL_Private_Macros STM32F4XX NUCLEO LOW LEVEL Private Macros 00094 * @{ 00095 */ 00096 /** 00097 * @} 00098 */ 00099 00100 /** @defgroup STM32F4XX_NUCLEO_LOW_LEVEL_Private_Variables STM32F4XX NUCLEO LOW LEVEL Private Variables 00101 * @{ 00102 */ 00103 GPIO_TypeDef* GPIO_PORT[LEDn] = {LED2_GPIO_PORT}; 00104 00105 const uint16_t GPIO_PIN[LEDn] = {LED2_PIN}; 00106 00107 GPIO_TypeDef* BUTTON_PORT[BUTTONn] = {KEY_BUTTON_GPIO_PORT}; 00108 const uint16_t BUTTON_PIN[BUTTONn] = {KEY_BUTTON_PIN}; 00109 const uint8_t BUTTON_IRQn[BUTTONn] = {KEY_BUTTON_EXTI_IRQn}; 00110 00111 /** 00112 * @brief BUS variables 00113 */ 00114 00115 #ifdef ADAFRUIT_TFT_JOY_SD_ID802 00116 #ifdef HAL_SPI_MODULE_ENABLED 00117 uint32_t SpixTimeout = NUCLEO_SPIx_TIMEOUT_MAX; /*<! Value of Timeout when SPI communication fails */ 00118 static SPI_HandleTypeDef hnucleo_Spi; 00119 #endif /* HAL_SPI_MODULE_ENABLED */ 00120 00121 #ifdef HAL_ADC_MODULE_ENABLED 00122 static ADC_HandleTypeDef hnucleo_Adc; 00123 /* ADC channel configuration structure declaration */ 00124 static ADC_ChannelConfTypeDef sConfig; 00125 #endif /* HAL_ADC_MODULE_ENABLED */ 00126 #endif /* ADAFRUIT_TFT_JOY_SD_ID802 */ 00127 00128 /** 00129 * @} 00130 */ 00131 00132 /** @defgroup STM32F4XX_NUCLEO_LOW_LEVEL_Private_FunctionPrototypes STM32F4XX NUCLEO LOW LEVEL Private FunctionPrototypes 00133 * @{ 00134 */ 00135 #ifdef ADAFRUIT_TFT_JOY_SD_ID802 00136 00137 #ifdef HAL_SPI_MODULE_ENABLED 00138 static void SPIx_Init(void); 00139 static void SPIx_Write(uint8_t Value); 00140 static void SPIx_WriteReadData(const uint8_t *DataIn, uint8_t *DataOut, uint16_t DataLegnth); 00141 static void SPIx_Error(void); 00142 static void SPIx_MspInit(SPI_HandleTypeDef *hspi); 00143 00144 /* SD IO functions */ 00145 void SD_IO_Init(void); 00146 void SD_IO_CSState(uint8_t state); 00147 void SD_IO_WriteReadData(const uint8_t *DataIn, uint8_t *DataOut, uint16_t DataLength); 00148 uint8_t SD_IO_WriteByte(uint8_t Data); 00149 00150 /* LCD IO functions */ 00151 void LCD_IO_Init(void); 00152 void LCD_IO_WriteData(uint8_t Data); 00153 void LCD_IO_WriteMultipleData(uint8_t *pData, uint32_t Size); 00154 void LCD_IO_WriteReg(uint8_t LCDReg); 00155 void LCD_Delay(uint32_t delay); 00156 #endif /* HAL_SPI_MODULE_ENABLED */ 00157 00158 #ifdef HAL_ADC_MODULE_ENABLED 00159 static void ADCx_Init(void); 00160 static void ADCx_DeInit(void); 00161 static void ADCx_MspInit(ADC_HandleTypeDef *hadc); 00162 static void ADCx_MspDeInit(ADC_HandleTypeDef *hadc); 00163 #endif /* HAL_ADC_MODULE_ENABLED */ 00164 00165 #endif /* ADAFRUIT_TFT_JOY_SD_ID802 */ 00166 00167 /** 00168 * @} 00169 */ 00170 00171 /** @defgroup STM32F4XX_NUCLEO_LOW_LEVEL_Private_Functions STM32F4XX NUCLEO LOW LEVEL Private Functions 00172 * @{ 00173 */ 00174 00175 /** 00176 * @brief This method returns the STM32F4xx NUCLEO BSP Driver revision 00177 * @retval version: 0xXYZR (8bits for each decimal, R for RC) 00178 */ 00179 uint32_t BSP_GetVersion(void) 00180 { 00181 return __STM32F4xx_NUCLEO_BSP_VERSION; 00182 } 00183 00184 /** 00185 * @brief Configures LED GPIO. 00186 * @param Led: Specifies the Led to be configured. 00187 * This parameter can be one of following parameters: 00188 * @arg LED2 00189 */ 00190 void BSP_LED_Init(Led_TypeDef Led) 00191 { 00192 GPIO_InitTypeDef GPIO_InitStruct; 00193 00194 /* Enable the GPIO_LED Clock */ 00195 LEDx_GPIO_CLK_ENABLE(Led); 00196 00197 /* Configure the GPIO_LED pin */ 00198 GPIO_InitStruct.Pin = GPIO_PIN[Led]; 00199 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; 00200 GPIO_InitStruct.Pull = GPIO_NOPULL; 00201 GPIO_InitStruct.Speed = GPIO_SPEED_FAST; 00202 00203 HAL_GPIO_Init(GPIO_PORT[Led], &GPIO_InitStruct); 00204 00205 HAL_GPIO_WritePin(GPIO_PORT[Led], GPIO_PIN[Led], GPIO_PIN_RESET); 00206 } 00207 00208 /** 00209 * @brief DeInit LEDs. 00210 * @param Led: LED to be de-init. 00211 * This parameter can be one of the following values: 00212 * @arg LED2 00213 * @note Led DeInit does not disable the GPIO clock nor disable the Mfx 00214 */ 00215 void BSP_LED_DeInit(Led_TypeDef Led) 00216 { 00217 GPIO_InitTypeDef gpio_init_structure; 00218 00219 /* Turn off LED */ 00220 HAL_GPIO_WritePin(GPIO_PORT[Led], GPIO_PIN[Led], GPIO_PIN_RESET); 00221 /* DeInit the GPIO_LED pin */ 00222 gpio_init_structure.Pin = GPIO_PIN[Led]; 00223 HAL_GPIO_DeInit(GPIO_PORT[Led], gpio_init_structure.Pin); 00224 } 00225 00226 /** 00227 * @brief Turns selected LED On. 00228 * @param Led: Specifies the Led to be set on. 00229 * This parameter can be one of following parameters: 00230 * @arg LED2 00231 */ 00232 void BSP_LED_On(Led_TypeDef Led) 00233 { 00234 HAL_GPIO_WritePin(GPIO_PORT[Led], GPIO_PIN[Led], GPIO_PIN_SET); 00235 } 00236 00237 /** 00238 * @brief Turns selected LED Off. 00239 * @param Led: Specifies the Led to be set off. 00240 * This parameter can be one of following parameters: 00241 * @arg LED2 00242 */ 00243 void BSP_LED_Off(Led_TypeDef Led) 00244 { 00245 HAL_GPIO_WritePin(GPIO_PORT[Led], GPIO_PIN[Led], GPIO_PIN_RESET); 00246 } 00247 00248 /** 00249 * @brief Toggles the selected LED. 00250 * @param Led: Specifies the Led to be toggled. 00251 * This parameter can be one of following parameters: 00252 * @arg LED2 00253 */ 00254 void BSP_LED_Toggle(Led_TypeDef Led) 00255 { 00256 HAL_GPIO_TogglePin(GPIO_PORT[Led], GPIO_PIN[Led]); 00257 } 00258 00259 /** 00260 * @brief Configures Button GPIO and EXTI Line. 00261 * @param Button: Specifies the Button to be configured. 00262 * This parameter should be: BUTTON_KEY 00263 * @param ButtonMode: Specifies Button mode. 00264 * This parameter can be one of following parameters: 00265 * @arg BUTTON_MODE_GPIO: Button will be used as simple IO 00266 * @arg BUTTON_MODE_EXTI: Button will be connected to EXTI line with interrupt 00267 * generation capability 00268 */ 00269 void BSP_PB_Init(Button_TypeDef Button, ButtonMode_TypeDef ButtonMode) 00270 { 00271 GPIO_InitTypeDef GPIO_InitStruct; 00272 00273 /* Enable the BUTTON Clock */ 00274 BUTTONx_GPIO_CLK_ENABLE(Button); 00275 00276 if(ButtonMode == BUTTON_MODE_GPIO) 00277 { 00278 /* Configure Button pin as input */ 00279 GPIO_InitStruct.Pin = BUTTON_PIN[Button]; 00280 GPIO_InitStruct.Mode = GPIO_MODE_INPUT; 00281 GPIO_InitStruct.Pull = GPIO_PULLDOWN; 00282 GPIO_InitStruct.Speed = GPIO_SPEED_FAST; 00283 HAL_GPIO_Init(BUTTON_PORT[Button], &GPIO_InitStruct); 00284 } 00285 00286 if(ButtonMode == BUTTON_MODE_EXTI) 00287 { 00288 /* Configure Button pin as input with External interrupt */ 00289 GPIO_InitStruct.Pin = BUTTON_PIN[Button]; 00290 GPIO_InitStruct.Pull = GPIO_NOPULL; 00291 GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING; 00292 HAL_GPIO_Init(BUTTON_PORT[Button], &GPIO_InitStruct); 00293 00294 /* Enable and set Button EXTI Interrupt to the lowest priority */ 00295 HAL_NVIC_SetPriority((IRQn_Type)(BUTTON_IRQn[Button]), 0x0F, 0x00); 00296 HAL_NVIC_EnableIRQ((IRQn_Type)(BUTTON_IRQn[Button])); 00297 } 00298 } 00299 00300 /** 00301 * @brief Push Button DeInit. 00302 * @param Button: Button to be configured 00303 * This parameter should be: BUTTON_KEY 00304 * @note PB DeInit does not disable the GPIO clock 00305 */ 00306 void BSP_PB_DeInit(Button_TypeDef Button) 00307 { 00308 GPIO_InitTypeDef gpio_init_structure; 00309 00310 gpio_init_structure.Pin = BUTTON_PIN[Button]; 00311 HAL_NVIC_DisableIRQ((IRQn_Type)(BUTTON_IRQn[Button])); 00312 HAL_GPIO_DeInit(BUTTON_PORT[Button], gpio_init_structure.Pin); 00313 } 00314 00315 /** 00316 * @brief Returns the selected Button state. 00317 * @param Button: Specifies the Button to be checked. 00318 * This parameter should be: BUTTON_KEY 00319 * @retval The Button GPIO pin value. 00320 */ 00321 uint32_t BSP_PB_GetState(Button_TypeDef Button) 00322 { 00323 return HAL_GPIO_ReadPin(BUTTON_PORT[Button], BUTTON_PIN[Button]); 00324 } 00325 00326 /****************************************************************************** 00327 BUS OPERATIONS 00328 *******************************************************************************/ 00329 #ifdef ADAFRUIT_TFT_JOY_SD_ID802 00330 00331 /******************************* SPI ********************************/ 00332 #ifdef HAL_SPI_MODULE_ENABLED 00333 00334 /** 00335 * @brief Initializes SPI MSP. 00336 */ 00337 static void SPIx_MspInit(SPI_HandleTypeDef *hspi) 00338 { 00339 GPIO_InitTypeDef GPIO_InitStruct; 00340 00341 /*** Configure the GPIOs ***/ 00342 /* Enable GPIO clock */ 00343 NUCLEO_SPIx_SCK_GPIO_CLK_ENABLE(); 00344 NUCLEO_SPIx_MISO_MOSI_GPIO_CLK_ENABLE(); 00345 00346 /* Configure SPI SCK */ 00347 GPIO_InitStruct.Pin = NUCLEO_SPIx_SCK_PIN; 00348 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; 00349 GPIO_InitStruct.Pull = GPIO_PULLUP; 00350 GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; 00351 GPIO_InitStruct.Alternate = NUCLEO_SPIx_SCK_AF; 00352 HAL_GPIO_Init(NUCLEO_SPIx_SCK_GPIO_PORT, &GPIO_InitStruct); 00353 00354 /* Configure SPI MISO and MOSI */ 00355 GPIO_InitStruct.Pin = NUCLEO_SPIx_MOSI_PIN; 00356 GPIO_InitStruct.Alternate = NUCLEO_SPIx_MISO_MOSI_AF; 00357 GPIO_InitStruct.Pull = GPIO_PULLDOWN; 00358 HAL_GPIO_Init(NUCLEO_SPIx_MISO_MOSI_GPIO_PORT, &GPIO_InitStruct); 00359 00360 GPIO_InitStruct.Pin = NUCLEO_SPIx_MISO_PIN; 00361 GPIO_InitStruct.Pull = GPIO_PULLDOWN; 00362 HAL_GPIO_Init(NUCLEO_SPIx_MISO_MOSI_GPIO_PORT, &GPIO_InitStruct); 00363 00364 /*** Configure the SPI peripheral ***/ 00365 /* Enable SPI clock */ 00366 NUCLEO_SPIx_CLK_ENABLE(); 00367 } 00368 00369 /** 00370 * @brief Initializes SPI HAL. 00371 */ 00372 static void SPIx_Init(void) 00373 { 00374 if(HAL_SPI_GetState(&hnucleo_Spi) == HAL_SPI_STATE_RESET) 00375 { 00376 /* SPI Config */ 00377 hnucleo_Spi.Instance = NUCLEO_SPIx; 00378 /* SPI baudrate is set to 12,5 MHz maximum (APB1/SPI_BaudRatePrescaler = 100/8 = 12,5 MHz) 00379 to verify these constraints: 00380 - ST7735 LCD SPI interface max baudrate is 15MHz for write and 6.66MHz for read 00381 Since the provided driver doesn't use read capability from LCD, only constraint 00382 on write baudrate is considered. 00383 - SD card SPI interface max baudrate is 25MHz for write/read 00384 - PCLK2 max frequency is 100 MHz 00385 */ 00386 hnucleo_Spi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8; 00387 hnucleo_Spi.Init.Direction = SPI_DIRECTION_2LINES; 00388 hnucleo_Spi.Init.CLKPhase = SPI_PHASE_2EDGE; 00389 hnucleo_Spi.Init.CLKPolarity = SPI_POLARITY_HIGH; 00390 hnucleo_Spi.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED; 00391 hnucleo_Spi.Init.CRCPolynomial = 7; 00392 hnucleo_Spi.Init.DataSize = SPI_DATASIZE_8BIT; 00393 hnucleo_Spi.Init.FirstBit = SPI_FIRSTBIT_MSB; 00394 hnucleo_Spi.Init.NSS = SPI_NSS_SOFT; 00395 hnucleo_Spi.Init.TIMode = SPI_TIMODE_DISABLED; 00396 hnucleo_Spi.Init.Mode = SPI_MODE_MASTER; 00397 00398 SPIx_MspInit(&hnucleo_Spi); 00399 HAL_SPI_Init(&hnucleo_Spi); 00400 } 00401 } 00402 00403 /** 00404 * @brief SPI Write a byte to device 00405 * @param DataIn: value to be written 00406 * @param DataOut: value to be read 00407 * @param DataLegnth: length of data 00408 */ 00409 static void SPIx_WriteReadData(const uint8_t *DataIn, uint8_t *DataOut, uint16_t DataLegnth) 00410 { 00411 HAL_StatusTypeDef status = HAL_OK; 00412 00413 status = HAL_SPI_TransmitReceive(&hnucleo_Spi, (uint8_t*) DataIn, DataOut, DataLegnth, SpixTimeout); 00414 00415 /* Check the communication status */ 00416 if(status != HAL_OK) 00417 { 00418 /* Execute user timeout callback */ 00419 SPIx_Error(); 00420 } 00421 } 00422 00423 /** 00424 * @brief SPI Write a byte to device. 00425 * @param Value: value to be written 00426 */ 00427 static void SPIx_Write(uint8_t Value) 00428 { 00429 HAL_StatusTypeDef status = HAL_OK; 00430 uint8_t data; 00431 00432 status = HAL_SPI_TransmitReceive(&hnucleo_Spi, (uint8_t*) &Value, &data, 1, SpixTimeout); 00433 00434 /* Check the communication status */ 00435 if(status != HAL_OK) 00436 { 00437 /* Execute user timeout callback */ 00438 SPIx_Error(); 00439 } 00440 } 00441 00442 /** 00443 * @brief SPI error treatment function. 00444 */ 00445 static void SPIx_Error (void) 00446 { 00447 /* De-initialize the SPI communication BUS */ 00448 HAL_SPI_DeInit(&hnucleo_Spi); 00449 00450 /* Re-Initiaize the SPI communication BUS */ 00451 SPIx_Init(); 00452 } 00453 00454 /****************************************************************************** 00455 LINK OPERATIONS 00456 *******************************************************************************/ 00457 00458 /********************************* LINK SD ************************************/ 00459 /** 00460 * @brief Initializes the SD Card and put it into StandBy State (Ready for 00461 * data transfer). 00462 */ 00463 void SD_IO_Init(void) 00464 { 00465 GPIO_InitTypeDef GPIO_InitStruct; 00466 uint8_t counter; 00467 00468 /* SD_CS_GPIO Periph clock enable */ 00469 SD_CS_GPIO_CLK_ENABLE(); 00470 00471 /* Configure SD_CS_PIN pin: SD Card CS pin */ 00472 GPIO_InitStruct.Pin = SD_CS_PIN; 00473 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; 00474 GPIO_InitStruct.Pull = GPIO_PULLUP; 00475 GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; 00476 HAL_GPIO_Init(SD_CS_GPIO_PORT, &GPIO_InitStruct); 00477 00478 /*------------Put SD in SPI mode--------------*/ 00479 /* SD SPI Config */ 00480 SPIx_Init(); 00481 00482 /* SD chip select high */ 00483 SD_CS_HIGH(); 00484 00485 /* Send dummy byte 0xFF, 10 times with CS high */ 00486 /* Rise CS and MOSI for 80 clocks cycles */ 00487 for (counter = 0; counter <= 9; counter++) 00488 { 00489 /* Send dummy byte 0xFF */ 00490 SD_IO_WriteByte(SD_DUMMY_BYTE); 00491 } 00492 } 00493 00494 /** 00495 * @brief Set the SD_CS pin. 00496 * @param val: pin value. 00497 */ 00498 void SD_IO_CSState(uint8_t val) 00499 { 00500 if(val == 1) 00501 { 00502 SD_CS_HIGH(); 00503 } 00504 else 00505 { 00506 SD_CS_LOW(); 00507 } 00508 } 00509 00510 /** 00511 * @brief Write a byte on the SD. 00512 * @param DataIn: value to be written 00513 * @param DataOut: value to be read 00514 * @param DataLength: length of data 00515 */ 00516 void SD_IO_WriteReadData(const uint8_t *DataIn, uint8_t *DataOut, uint16_t DataLength) 00517 { 00518 /* Send the byte */ 00519 SPIx_WriteReadData(DataIn, DataOut, DataLength); 00520 } 00521 00522 /** 00523 * @brief Writes a byte on the SD. 00524 * @param Data: byte to send. 00525 */ 00526 uint8_t SD_IO_WriteByte(uint8_t Data) 00527 { 00528 uint8_t tmp; 00529 /* Send the byte */ 00530 SPIx_WriteReadData(&Data,&tmp,1); 00531 return tmp; 00532 } 00533 00534 /********************************* LINK LCD ***********************************/ 00535 /** 00536 * @brief Initializes the LCD. 00537 */ 00538 void LCD_IO_Init(void) 00539 { 00540 GPIO_InitTypeDef GPIO_InitStruct; 00541 00542 /* LCD_CS_GPIO and LCD_DC_GPIO Periph clock enable */ 00543 LCD_CS_GPIO_CLK_ENABLE(); 00544 LCD_DC_GPIO_CLK_ENABLE(); 00545 00546 /* Configure LCD_CS_PIN pin: LCD Card CS pin */ 00547 GPIO_InitStruct.Pin = LCD_CS_PIN; 00548 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; 00549 GPIO_InitStruct.Pull = GPIO_NOPULL; 00550 GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; 00551 HAL_GPIO_Init(LCD_CS_GPIO_PORT, &GPIO_InitStruct); 00552 00553 /* Configure LCD_DC_PIN pin: LCD Card DC pin */ 00554 GPIO_InitStruct.Pin = LCD_DC_PIN; 00555 HAL_GPIO_Init(LCD_DC_GPIO_PORT, &GPIO_InitStruct); 00556 00557 /* LCD chip select high */ 00558 LCD_CS_HIGH(); 00559 00560 /* LCD SPI Config */ 00561 SPIx_Init(); 00562 } 00563 00564 /** 00565 * @brief Writes command to select the LCD register. 00566 * @param LCDReg: Address of the selected register. 00567 */ 00568 void LCD_IO_WriteReg(uint8_t LCDReg) 00569 { 00570 /* Reset LCD control line CS */ 00571 LCD_CS_LOW(); 00572 00573 /* Set LCD data/command line DC to Low */ 00574 LCD_DC_LOW(); 00575 00576 /* Send Command */ 00577 SPIx_Write(LCDReg); 00578 00579 /* Deselect : Chip Select high */ 00580 LCD_CS_HIGH(); 00581 } 00582 00583 /** 00584 * @brief Writes data to select the LCD register. 00585 * This function must be used after st7735_WriteReg() function 00586 * @param Data: data to write to the selected register. 00587 */ 00588 void LCD_IO_WriteData(uint8_t Data) 00589 { 00590 /* Reset LCD control line CS */ 00591 LCD_CS_LOW(); 00592 00593 /* Set LCD data/command line DC to High */ 00594 LCD_DC_HIGH(); 00595 00596 /* Send Data */ 00597 SPIx_Write(Data); 00598 00599 /* Deselect : Chip Select high */ 00600 LCD_CS_HIGH(); 00601 } 00602 00603 /** 00604 * @brief Writes register value. 00605 * @param pData: Pointer on the register value 00606 * @param Size: Size of byte to transmit to the register 00607 */ 00608 void LCD_IO_WriteMultipleData(uint8_t *pData, uint32_t Size) 00609 { 00610 uint32_t counter = 0; 00611 __IO uint32_t data = 0; 00612 00613 /* Reset LCD control line CS */ 00614 LCD_CS_LOW(); 00615 00616 /* Set LCD data/command line DC to High */ 00617 LCD_DC_HIGH(); 00618 00619 if (Size == 1) 00620 { 00621 /* Only 1 byte to be sent to LCD - general interface can be used */ 00622 /* Send Data */ 00623 SPIx_Write(*pData); 00624 } 00625 else 00626 { 00627 /* Several data should be sent in a raw */ 00628 /* Direct SPI accesses for optimization */ 00629 for (counter = Size; counter != 0; counter--) 00630 { 00631 while(((hnucleo_Spi.Instance->SR) & SPI_FLAG_TXE) != SPI_FLAG_TXE) 00632 { 00633 } 00634 /* Need to invert bytes for LCD*/ 00635 *((__IO uint8_t*)&hnucleo_Spi.Instance->DR) = *(pData+1); 00636 00637 while(((hnucleo_Spi.Instance->SR) & SPI_FLAG_TXE) != SPI_FLAG_TXE) 00638 { 00639 } 00640 *((__IO uint8_t*)&hnucleo_Spi.Instance->DR) = *pData; 00641 counter--; 00642 pData += 2; 00643 } 00644 00645 /* Wait until the bus is ready before releasing Chip select */ 00646 while(((hnucleo_Spi.Instance->SR) & SPI_FLAG_BSY) != RESET) 00647 { 00648 } 00649 } 00650 00651 /* Empty the Rx fifo */ 00652 data = *(&hnucleo_Spi.Instance->DR); 00653 00654 /* Deselect : Chip Select high */ 00655 LCD_CS_HIGH(); 00656 } 00657 00658 /** 00659 * @brief Wait for loop in ms. 00660 * @param Delay in ms. 00661 */ 00662 void LCD_Delay(uint32_t Delay) 00663 { 00664 HAL_Delay(Delay); 00665 } 00666 #endif /* HAL_SPI_MODULE_ENABLED */ 00667 00668 /******************************* ADC driver ********************************/ 00669 #ifdef HAL_ADC_MODULE_ENABLED 00670 00671 /** 00672 * @brief Initializes ADC MSP. 00673 */ 00674 static void ADCx_MspInit(ADC_HandleTypeDef *hadc) 00675 { 00676 GPIO_InitTypeDef GPIO_InitStruct; 00677 00678 /*** Configure the GPIOs ***/ 00679 /* Enable GPIO clock */ 00680 NUCLEO_ADCx_GPIO_CLK_ENABLE(); 00681 00682 /* Configure the selected ADC Channel as analog input */ 00683 GPIO_InitStruct.Pin = NUCLEO_ADCx_GPIO_PIN ; 00684 GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; 00685 GPIO_InitStruct.Pull = GPIO_NOPULL; 00686 HAL_GPIO_Init(NUCLEO_ADCx_GPIO_PORT, &GPIO_InitStruct); 00687 00688 /*** Configure the ADC peripheral ***/ 00689 /* Enable ADC clock */ 00690 NUCLEO_ADCx_CLK_ENABLE(); 00691 } 00692 00693 /** 00694 * @brief DeInitializes ADC MSP. 00695 * @note ADC DeInit does not disable the GPIO clock 00696 */ 00697 static void ADCx_MspDeInit(ADC_HandleTypeDef *hadc) 00698 { 00699 GPIO_InitTypeDef GPIO_InitStruct; 00700 00701 /*** DeInit the ADC peripheral ***/ 00702 /* Disable ADC clock */ 00703 NUCLEO_ADCx_CLK_DISABLE(); 00704 00705 /* Configure the selected ADC Channel as analog input */ 00706 GPIO_InitStruct.Pin = NUCLEO_ADCx_GPIO_PIN ; 00707 HAL_GPIO_DeInit(NUCLEO_ADCx_GPIO_PORT, GPIO_InitStruct.Pin); 00708 00709 /* Disable GPIO clock has to be done by the application*/ 00710 /* NUCLEO_ADCx_GPIO_CLK_DISABLE(); */ 00711 } 00712 00713 /** 00714 * @brief Initializes ADC HAL. 00715 */ 00716 static void ADCx_Init(void) 00717 { 00718 if(HAL_ADC_GetState(&hnucleo_Adc) == HAL_ADC_STATE_RESET) 00719 { 00720 /* ADC Config */ 00721 hnucleo_Adc.Instance = NUCLEO_ADCx; 00722 hnucleo_Adc.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV4; /* (must not exceed 36MHz) */ 00723 hnucleo_Adc.Init.Resolution = ADC_RESOLUTION12b; 00724 hnucleo_Adc.Init.DataAlign = ADC_DATAALIGN_RIGHT; 00725 hnucleo_Adc.Init.ContinuousConvMode = DISABLE; 00726 hnucleo_Adc.Init.DiscontinuousConvMode = DISABLE; 00727 hnucleo_Adc.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; 00728 hnucleo_Adc.Init.EOCSelection = EOC_SINGLE_CONV; 00729 hnucleo_Adc.Init.NbrOfConversion = 1; 00730 hnucleo_Adc.Init.DMAContinuousRequests = DISABLE; 00731 00732 ADCx_MspInit(&hnucleo_Adc); 00733 HAL_ADC_Init(&hnucleo_Adc); 00734 } 00735 } 00736 00737 /** 00738 * @brief Initializes ADC HAL. 00739 */ 00740 static void ADCx_DeInit(void) 00741 { 00742 hnucleo_Adc.Instance = NUCLEO_ADCx; 00743 00744 HAL_ADC_DeInit(&hnucleo_Adc); 00745 ADCx_MspDeInit(&hnucleo_Adc); 00746 } 00747 00748 /******************************* LINK JOYSTICK ********************************/ 00749 00750 /** 00751 * @brief Configures joystick available on adafruit 1.8" TFT shield 00752 * managed through ADC to detect motion. 00753 * @retval Joystickstatus (0=> success, 1=> fail) 00754 */ 00755 uint8_t BSP_JOY_Init(void) 00756 { 00757 uint8_t status = HAL_ERROR; 00758 00759 ADCx_Init(); 00760 00761 /* Select the ADC Channel to be converted */ 00762 sConfig.Channel = NUCLEO_ADCx_CHANNEL; 00763 sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES; 00764 sConfig.Rank = 1; 00765 status = HAL_ADC_ConfigChannel(&hnucleo_Adc, &sConfig); 00766 00767 /* Return Joystick initialization status */ 00768 return status; 00769 } 00770 00771 /** 00772 * @brief DeInit joystick GPIOs. 00773 * @note JOY DeInit does not disable the Mfx, just set the Mfx pins in Off modee. 00774 */ 00775 void BSP_JOY_DeInit(void) 00776 { 00777 ADCx_DeInit(); 00778 } 00779 00780 /** 00781 * @brief Returns the Joystick key pressed. 00782 * @note To know which Joystick key is pressed we need to detect the voltage 00783 * level on each key output 00784 * - None : 3.3 V / 4095 00785 * - SEL : 1.055 V / 1308 00786 * - DOWN : 0.71 V / 88 00787 * - LEFT : 3.0 V / 3720 00788 * - RIGHT : 0.595 V / 737 00789 * - UP : 1.65 V / 2046 00790 * @retval JOYState_TypeDef: Code of the Joystick key pressed. 00791 */ 00792 JOYState_TypeDef BSP_JOY_GetState(void) 00793 { 00794 JOYState_TypeDef state; 00795 uint16_t keyconvertedvalue = 0; 00796 00797 /* Start the conversion process */ 00798 HAL_ADC_Start(&hnucleo_Adc); 00799 00800 /* Wait for the end of conversion */ 00801 HAL_ADC_PollForConversion(&hnucleo_Adc, 10); 00802 00803 /* Check if the continuous conversion of regular channel is finished */ 00804 if(HAL_ADC_GetState(&hnucleo_Adc) == HAL_ADC_STATE_EOC_REG) 00805 { 00806 /* Get the converted value of regular channel */ 00807 keyconvertedvalue = HAL_ADC_GetValue(&hnucleo_Adc); 00808 } 00809 00810 if((keyconvertedvalue > 2010) && (keyconvertedvalue < 2090)) 00811 { 00812 state = JOY_UP; 00813 } 00814 else if((keyconvertedvalue > 680) && (keyconvertedvalue < 780)) 00815 { 00816 state = JOY_RIGHT; 00817 } 00818 else if((keyconvertedvalue > 1270) && (keyconvertedvalue < 1350)) 00819 { 00820 state = JOY_SEL; 00821 } 00822 else if((keyconvertedvalue > 50) && (keyconvertedvalue < 130)) 00823 { 00824 state = JOY_DOWN; 00825 } 00826 else if((keyconvertedvalue > 3680) && (keyconvertedvalue < 3760)) 00827 { 00828 state = JOY_LEFT; 00829 } 00830 else 00831 { 00832 state = JOY_NONE; 00833 } 00834 00835 /* Loop while a key is pressed */ 00836 if(state != JOY_NONE) 00837 { 00838 keyconvertedvalue = HAL_ADC_GetValue(&hnucleo_Adc); 00839 } 00840 /* Return the code of the Joystick key pressed */ 00841 return state; 00842 } 00843 #endif /* HAL_ADC_MODULE_ENABLED */ 00844 00845 #endif /* ADAFRUIT_TFT_JOY_SD_ID802 */ 00846 00847 00848 /** 00849 * @} 00850 */ 00851 00852 /** 00853 * @} 00854 */ 00855 00856 /** 00857 * @} 00858 */ 00859 00860 /** 00861 * @} 00862 */ 00863 00864 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
Generated on Tue Jan 12 2016 13:17:23 for STM32F4xx_Nucleo BSP User Manual by
![doxygen](doxygen.png)