void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi) { GPIO_InitTypeDef GPIO_InitStruct; if(hspi->Instance==SPI2) { /* USER CODE BEGIN SPI2_MspInit 0 */ /* USER CODE END SPI2_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_SPI2_CLK_ENABLE(); /**SPI2 GPIO Configuration PB15 ------> SPI2_MOSI PB10 ------> SPI2_SCK PB14 ------> SPI2_MISO */ GPIO_InitStruct.Pin = AP_SPI_MOSI_Pin|AP_SPI_SCK_Pin|AP_SPI_MISO_Pin; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF5_SPI2; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* USER CODE BEGIN SPI2_MspInit 1 */ /* USER CODE END SPI2_MspInit 1 */ } else if(hspi->Instance==SPI3) { /* USER CODE BEGIN SPI3_MspInit 0 */ /* USER CODE END SPI3_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_SPI3_CLK_ENABLE(); /**SPI3 GPIO Configuration PB4 ------> SPI3_MISO PB5 ------> SPI3_MOSI PB12 ------> SPI3_SCK */ GPIO_InitStruct.Pin = SENSOR_SPI_MISO_Pin|SENSOR_SPI_MOSI_Pin; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF6_SPI3; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); GPIO_InitStruct.Pin = SENSOR_SPI_SCK_Pin; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF7_SPI3; HAL_GPIO_Init(SENSOR_SPI_SCK_GPIO_Port, &GPIO_InitStruct); /* USER CODE BEGIN SPI3_MspInit 1 */ /* USER CODE END SPI3_MspInit 1 */ } }
void HAL_SPI_MspInit(SPI_HandleTypeDef* spiHandle) { GPIO_InitTypeDef GPIO_InitStruct; if(spiHandle->Instance==SPI1) { /* USER CODE BEGIN SPI1_MspInit 0 */ /* USER CODE END SPI1_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_SPI1_CLK_ENABLE(); /**SPI1 GPIO Configuration PA5 ------> SPI1_SCK PA6 ------> SPI1_MISO PA7 ------> SPI1_MOSI */ GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_6|SPI1_MISO_Pin; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.Alternate = GPIO_AF5_SPI1; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* USER CODE BEGIN SPI1_MspInit 1 */ /* USER CODE END SPI1_MspInit 1 */ } else if(spiHandle->Instance==SPI3) { /* USER CODE BEGIN SPI3_MspInit 0 */ /* USER CODE END SPI3_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_SPI3_CLK_ENABLE(); /**SPI3 GPIO Configuration PC10 ------> SPI3_SCK PC11 ------> SPI3_MISO PC12 ------> SPI3_MOSI */ GPIO_InitStruct.Pin = SD_SCK_Pin|SD_MOSI_Pin; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.Alternate = GPIO_AF6_SPI3; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); GPIO_InitStruct.Pin = SD_MISO_Pin; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.Alternate = GPIO_AF6_SPI3; HAL_GPIO_Init(SD_MISO_GPIO_Port, &GPIO_InitStruct); /* USER CODE BEGIN SPI3_MspInit 1 */ /* USER CODE END SPI3_MspInit 1 */ } }
/** * @brief SPI MSP Initialization * This function configures the hardware resources used in this example * @param hspi: SPI handle pointer * @retval None */ void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi) { GPIO_InitTypeDef GPIO_InitStruct = {0}; if(hspi->Instance==SPI3) { /* USER CODE BEGIN SPI3_MspInit 0 */ /* USER CODE END SPI3_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_SPI3_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE(); /**SPI3 GPIO Configuration PB3 ------> SPI3_SCK PB4 ------> SPI3_MISO PB5 ------> SPI3_MOSI */ GPIO_InitStruct.Pin = GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF6_SPI3; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* USER CODE BEGIN SPI3_MspInit 1 */ /* USER CODE END SPI3_MspInit 1 */ } }
void HAL_SPI_MspInit(SPI_HandleTypeDef* spiHandle) { GPIO_InitTypeDef GPIO_InitStruct; if(spiHandle->Instance==SPI1) { /* SPI1 clock enable */ __HAL_RCC_SPI1_CLK_ENABLE(); __HAL_RCC_GPIOA_CLK_ENABLE(); /**SPI1 GPIO Configuration PA5 ------> SPI1_SCK PA6 ------> SPI1_MISO PA7 ------> SPI1_MOSI */ GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF5_SPI1; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); } else if(spiHandle->Instance==SPI2) { /* SPI2 clock enable */ __HAL_RCC_SPI2_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE(); /**SPI2 GPIO Configuration PB13 ------> SPI2_SCK PB14 ------> SPI2_MISO PB15 ------> SPI2_MOSI */ GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF5_SPI2; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); } else if(spiHandle->Instance==SPI3) { /* SPI3 clock enable */ __HAL_RCC_SPI3_CLK_ENABLE(); __HAL_RCC_GPIOC_CLK_ENABLE(); /**SPI3 GPIO Configuration PC10 ------> SPI3_SCK PC11 ------> SPI3_MISO PC12 ------> SPI3_MOSI */ GPIO_InitStruct.Pin = GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF6_SPI3; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); } }
/** * @brief * SPI 3 INIT Return HAL status * Config: * Prescaler: 2 * Direction: 2 lines * 8 bit data * Phase 1 edge * Polarity LOW * CRC Disabled * First bit MSB * NSS SOFT * @{ */ uint8_t spi3_nRF_init(void){ uint8_t spi_status = SPI_INIT_ERROR; //Przypisanie wartosci error na poczatku __HAL_RCC_SPI3_CLK_ENABLE(); //SET CLOCK FOR SPI2 gpio_init_for_spi3(); //GPIO Init for SPI gpio_nRF_rx_init(); //GPIO Init for nRF rx pins like ( TX_CE , DR) gpio_it_nRF_rx_init(); //GPIO IT init for nRF pin RD /* ============================================================== NOTATKI DO CONFIGURACJI SPI Wstepnie ustawiam na FULL Duplex master Bez sumy kontrolnej 8 Bit danych Direction 2 lines Prescaler 64 SPI PHASE 1 EDGE ============================================================== */ spi3_init_handle.Instance = SPI3; spi3_init_handle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64; // 80MHz / 64 = 1250000 Hz spi3_init_handle.Init.DataSize = SPI_DATASIZE_8BIT; spi3_init_handle.Init.Direction = SPI_DIRECTION_2LINES; spi3_init_handle.Init.Mode = SPI_MODE_MASTER; spi3_init_handle.Init.CLKPhase = SPI_PHASE_1EDGE; spi3_init_handle.Init.CLKPolarity = SPI_POLARITY_LOW; spi3_init_handle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED; spi3_init_handle.Init.FirstBit = SPI_FIRSTBIT_MSB; spi3_init_handle.Init.NSS = SPI_NSS_HARD_OUTPUT; spi3_init_handle.Init.TIMode = SPI_TIMODE_DISABLED; spi3_init_handle.Init.CRCPolynomial = 7; spi3_init_handle.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE; spi3_init_handle.Init.NSSPMode = SPI_NSS_PULSE_ENABLE; spi_status = HAL_SPI_Init(&spi3_init_handle); //INIT SPI3 if(spi_status != 0){ //IF ERROR OCURS usart2_WriteS("\n#ERROR IN SPI3 INIT!"); error_function(); } return spi_status; //RETURN SPI INIT STATUS }
void HAL_I2S_MspInit(I2S_HandleTypeDef* hi2s) { GPIO_InitTypeDef GPIO_InitStruct; if(hi2s->Instance==SPI3) { /* USER CODE BEGIN SPI3_MspInit 0 */ /* USER CODE END SPI3_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_SPI3_CLK_ENABLE(); /**I2S3 GPIO Configuration PA15 ------> I2S3_WS PC10 ------> I2S3_CK PC11 ------> I2S3_ext_SD PC12 ------> I2S3_SD */ GPIO_InitStruct.Pin = GPIO_PIN_15; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; GPIO_InitStruct.Alternate = GPIO_AF6_SPI3; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_10|GPIO_PIN_12; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; GPIO_InitStruct.Alternate = GPIO_AF6_SPI3; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_11; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; GPIO_InitStruct.Alternate = GPIO_AF5_I2S3ext; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); /* USER CODE BEGIN SPI3_MspInit 1 */ /* USER CODE END SPI3_MspInit 1 */ } }
/** * @brief SPI initialization function * @param obj : pointer to spi_t structure * @param speed : spi output speed * @param mode : one of the spi modes * @param msb : set to 1 in msb first * @retval None */ void spi_init(spi_t *obj, uint32_t speed, spi_mode_e mode, uint8_t msb) { if(obj == NULL) return; SPI_HandleTypeDef *handle = &(obj->handle); GPIO_InitTypeDef GPIO_InitStruct; GPIO_TypeDef *port; uint32_t spi_freq = 0; // Determine the SPI to use SPI_TypeDef *spi_mosi = pinmap_peripheral(obj->pin_mosi, PinMap_SPI_MOSI); SPI_TypeDef *spi_miso = pinmap_peripheral(obj->pin_miso, PinMap_SPI_MISO); SPI_TypeDef *spi_sclk = pinmap_peripheral(obj->pin_sclk, PinMap_SPI_SCLK); SPI_TypeDef *spi_ssel = pinmap_peripheral(obj->pin_ssel, PinMap_SPI_SSEL); /* Pins MOSI/MISO/SCLK must not be NP. ssel can be NP. */ if(spi_mosi == NP || spi_miso == NP || spi_sclk == NP) { printf("ERROR: at least one SPI pin has no peripheral\n"); return; } SPI_TypeDef *spi_data = pinmap_merge_peripheral(spi_mosi, spi_miso); SPI_TypeDef *spi_cntl = pinmap_merge_peripheral(spi_sclk, spi_ssel); obj->spi = pinmap_merge_peripheral(spi_data, spi_cntl); // Are all pins connected to the same SPI instance? if(obj->spi == NP) { printf("ERROR: SPI pins mismatch\n"); return; } // Configure the SPI pins if (obj->pin_ssel != NC) { handle->Init.NSS = SPI_NSS_HARD_OUTPUT; } else { handle->Init.NSS = SPI_NSS_SOFT; } /* Fill default value */ handle->Instance = obj->spi; handle->Init.Mode = SPI_MODE_MASTER; spi_freq = spi_getClkFreqInst(obj->spi); if(speed >= (spi_freq/SPI_SPEED_CLOCK_DIV2_MHZ)) { handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2; } else if(speed >= (spi_freq/SPI_SPEED_CLOCK_DIV4_MHZ)) { handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4; } else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV8_MHZ)) { handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8; } else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV16_MHZ)) { handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16; } else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV32_MHZ)) { handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32; } else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV64_MHZ)) { handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64; } else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV128_MHZ)) { handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128; } else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV256_MHZ)) { handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256; } else { handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16; } handle->Init.Direction = SPI_DIRECTION_2LINES; if((mode == SPI_MODE_0)||(mode == SPI_MODE_2)) { handle->Init.CLKPhase = SPI_PHASE_1EDGE; } else { handle->Init.CLKPhase = SPI_PHASE_2EDGE; } if((mode == SPI_MODE_0)||(mode == SPI_MODE_1)) { handle->Init.CLKPolarity = SPI_POLARITY_LOW; } else { handle->Init.CLKPolarity = SPI_POLARITY_HIGH; } handle->Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE; handle->Init.CRCPolynomial = 7; handle->Init.DataSize = SPI_DATASIZE_8BIT; if(msb == 0) { handle->Init.FirstBit = SPI_FIRSTBIT_LSB; } else { handle->Init.FirstBit = SPI_FIRSTBIT_MSB; } handle->Init.TIMode = SPI_TIMODE_DISABLE; #if defined(STM32F0xx) || defined(STM32F3xx) || defined(STM32F7xx) || defined(STM32L4xx) handle->Init.NSSPMode = SPI_NSS_PULSE_DISABLE; #endif if(obj->pin_mosi != NC) { port = set_GPIO_Port_Clock(STM_PORT(obj->pin_mosi)); GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_mosi); GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI)); GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI)); GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; #ifdef STM32F1xx pin_SetF1AFPin(STM_PIN_AFNUM(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI))); #else GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI)); #endif /* STM32F1xx */ HAL_GPIO_Init(port, &GPIO_InitStruct); } if(obj->pin_miso != NC) { port = set_GPIO_Port_Clock(STM_PORT(obj->pin_miso)); GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_miso); GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_miso,PinMap_SPI_MISO)); GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_miso,PinMap_SPI_MISO)); GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; #ifdef STM32F1xx pin_SetF1AFPin(STM_PIN_AFNUM(pinmap_function(obj->pin_miso,PinMap_SPI_MISO))); #else GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_miso,PinMap_SPI_MISO)); #endif /* STM32F1xx */ HAL_GPIO_Init(port, &GPIO_InitStruct); } if(obj->pin_sclk != NC) { port = set_GPIO_Port_Clock(STM_PORT(obj->pin_sclk)); GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_sclk); GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_sclk,PinMap_SPI_SCLK)); /* * According the STM32 Datasheet for SPI peripheral we need to PULLDOWN * or PULLUP the SCK pin according the polarity used. */ if(handle->Init.CLKPolarity == SPI_POLARITY_LOW) { GPIO_InitStruct.Pull = GPIO_PULLDOWN; } else { GPIO_InitStruct.Pull = GPIO_PULLUP; } GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; #ifdef STM32F1xx pin_SetF1AFPin(STM_PIN_AFNUM(pinmap_function(obj->pin_sclk,PinMap_SPI_SCLK))); #else GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_sclk,PinMap_SPI_SCLK)); #endif /* STM32F1xx */ HAL_GPIO_Init(port, &GPIO_InitStruct); } if(obj->pin_ssel != NC) { port = set_GPIO_Port_Clock(STM_PORT(obj->pin_ssel)); GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_ssel); GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL)); GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL)); GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; #ifdef STM32F1xx pin_SetF1AFPin(STM_PIN_AFNUM(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL))); #else GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL)); #endif /* STM32F1xx */ HAL_GPIO_Init(port, &GPIO_InitStruct); } #if defined SPI1_BASE // Enable SPI clock if (handle->Instance == SPI1) { __HAL_RCC_SPI1_CLK_ENABLE(); } #endif #if defined SPI2_BASE if (handle->Instance == SPI2) { __HAL_RCC_SPI2_CLK_ENABLE(); } #endif #if defined SPI3_BASE if (handle->Instance == SPI3) { __HAL_RCC_SPI3_CLK_ENABLE(); } #endif #if defined SPI4_BASE if (handle->Instance == SPI4) { __HAL_RCC_SPI4_CLK_ENABLE(); } #endif #if defined SPI5_BASE if (handle->Instance == SPI5) { __HAL_RCC_SPI5_CLK_ENABLE(); } #endif #if defined SPI6_BASE if (handle->Instance == SPI6) { __HAL_RCC_SPI6_CLK_ENABLE(); } #endif HAL_SPI_Init(handle); /* In order to set correctly the SPI polarity we need to enable the peripheral */ __HAL_SPI_ENABLE(handle); }
/* Private functions */ static void TM_SPIx_Init(SPI_TypeDef* SPIx, TM_SPI_PinsPack_t pinspack, TM_SPI_Mode_t SPI_Mode, uint16_t SPI_BaudRatePrescaler, uint16_t SPI_MasterSlave, uint16_t SPI_FirstBit) { SPI_HandleTypeDef SPIHandle; /* Save instance */ SPIHandle.Instance = SPIx; #ifdef SPI1 if (SPIx == SPI1) { /* Enable SPI clock */ __HAL_RCC_SPI1_CLK_ENABLE(); /* Init pins */ TM_SPI1_INT_InitPins(pinspack); /* Set options */ SPIHandle.Init.DataSize = TM_SPI1_DATASIZE; } #endif #ifdef SPI2 if (SPIx == SPI2) { /* Enable SPI clock */ __HAL_RCC_SPI2_CLK_ENABLE(); /* Init pins */ TM_SPI2_INT_InitPins(pinspack); /* Set options */ SPIHandle.Init.DataSize = TM_SPI2_DATASIZE; } #endif #ifdef SPI3 if (SPIx == SPI3) { /* Enable SPI clock */ __HAL_RCC_SPI3_CLK_ENABLE(); /* Init pins */ TM_SPI3_INT_InitPins(pinspack); /* Set options */ SPIHandle.Init.DataSize = TM_SPI3_DATASIZE; } #endif #ifdef SPI4 if (SPIx == SPI4) { /* Enable SPI clock */ __HAL_RCC_SPI4_CLK_ENABLE(); /* Init pins */ TM_SPI4_INT_InitPins(pinspack); /* Set options */ SPIHandle.Init.DataSize = TM_SPI4_DATASIZE; } #endif #ifdef SPI5 if (SPIx == SPI5) { /* Enable SPI clock */ __HAL_RCC_SPI5_CLK_ENABLE(); /* Init pins */ TM_SPI5_INT_InitPins(pinspack); /* Set options */ SPIHandle.Init.DataSize = TM_SPI5_DATASIZE; } #endif #ifdef SPI6 if (SPIx == SPI6) { /* Enable SPI clock */ __HAL_RCC_SPI6_CLK_ENABLE(); /* Init pins */ TM_SPI6_INT_InitPins(pinspack); /* Set options */ SPIHandle.Init.DataSize = TM_SPI6_DATASIZE; } #endif /* Fill SPI settings */ SPIHandle.Init.BaudRatePrescaler = SPI_BaudRatePrescaler; SPIHandle.Init.FirstBit = SPI_FirstBit; SPIHandle.Init.Mode = SPI_MasterSlave; SPIHandle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE; SPIHandle.Init.CRCPolynomial = 7; SPIHandle.Init.TIMode = SPI_TIMODE_DISABLE; SPIHandle.Init.NSS = SPI_NSS_SOFT; SPIHandle.Init.Direction = SPI_DIRECTION_2LINES; #if defined(STM32F7xx) SPIHandle.Init.NSSPMode = SPI_NSS_PULSE_DISABLE; SPIHandle.Init.CRCLength = SPI_CRC_LENGTH_8BIT; #endif /* SPI mode */ if (SPI_Mode == TM_SPI_Mode_0) { SPIHandle.Init.CLKPolarity = SPI_POLARITY_LOW; SPIHandle.Init.CLKPhase = SPI_PHASE_1EDGE; } else if (SPI_Mode == TM_SPI_Mode_1) { SPIHandle.Init.CLKPolarity = SPI_POLARITY_LOW; SPIHandle.Init.CLKPhase = SPI_PHASE_2EDGE; } else if (SPI_Mode == TM_SPI_Mode_2) { SPIHandle.Init.CLKPolarity = SPI_POLARITY_HIGH; SPIHandle.Init.CLKPhase = SPI_PHASE_1EDGE; } else if (SPI_Mode == TM_SPI_Mode_3) { SPIHandle.Init.CLKPolarity = SPI_POLARITY_HIGH; SPIHandle.Init.CLKPhase = SPI_PHASE_2EDGE; } /* Disable first */ __HAL_SPI_DISABLE(&SPIHandle); /* Init SPI */ HAL_SPI_Init(&SPIHandle); /* Enable SPI */ __HAL_SPI_ENABLE(&SPIHandle); }
int hal_spi_config(int spi_num, struct hal_spi_settings *settings) { struct stm32_hal_spi *spi; struct stm32_hal_spi_cfg *cfg; SPI_InitTypeDef *init; GPIO_InitTypeDef gpio; uint32_t gpio_speed; IRQn_Type irq; uint32_t prescaler; int rc; int sr; __HAL_DISABLE_INTERRUPTS(sr); STM32_HAL_SPI_RESOLVE(spi_num, spi); init = &spi->handle.Init; cfg = spi->cfg; if (!spi->slave) { spi->handle.Init.NSS = SPI_NSS_HARD_OUTPUT; spi->handle.Init.Mode = SPI_MODE_MASTER; } else { spi->handle.Init.NSS = SPI_NSS_SOFT; spi->handle.Init.Mode = SPI_MODE_SLAVE; } gpio.Mode = GPIO_MODE_AF_PP; gpio.Pull = GPIO_NOPULL; /* TODO: also VERY_HIGH for STM32L1x */ if (settings->baudrate <= 2000) { gpio_speed = GPIO_SPEED_FREQ_LOW; } else if (settings->baudrate <= 12500) { gpio_speed = GPIO_SPEED_FREQ_MEDIUM; } else { gpio_speed = GPIO_SPEED_FREQ_HIGH; } /* Enable the clocks for this SPI */ switch (spi_num) { #if SPI_0_ENABLED case 0: __HAL_RCC_SPI1_CLK_ENABLE(); #if !defined(STM32F1) gpio.Alternate = GPIO_AF5_SPI1; #endif spi->handle.Instance = SPI1; break; #endif #if SPI_1_ENABLED case 1: __HAL_RCC_SPI2_CLK_ENABLE(); #if !defined(STM32F1) gpio.Alternate = GPIO_AF5_SPI2; #endif spi->handle.Instance = SPI2; break; #endif #if SPI_2_ENABLED case 2: __HAL_RCC_SPI3_CLK_ENABLE(); #if !defined(STM32F1) gpio.Alternate = GPIO_AF6_SPI3; #endif spi->handle.Instance = SPI3; break; #endif #if SPI_3_ENABLED case 3: __HAL_RCC_SPI4_CLK_ENABLE(); #if !defined(STM32F1) gpio.Alternate = GPIO_AF5_SPI4; #endif spi->handle.Instance = SPI4; break; #endif #if SPI_4_ENABLED case 4: __HAL_RCC_SPI5_CLK_ENABLE(); #if !defined(STM32F1) gpio.Alternate = GPIO_AF5_SPI5; #endif spi->handle.Instance = SPI5; break; #endif #if SPI_5_ENABLED case 5: __HAL_RCC_SPI6_CLK_ENABLE(); #if !defined(STM32F1) gpio.Alternate = GPIO_AF5_SPI6; #endif spi->handle.Instance = SPI6; break; #endif default: assert(0); rc = -1; goto err; } if (!spi->slave) { if (settings->data_mode == HAL_SPI_MODE2 || settings->data_mode == HAL_SPI_MODE3) { gpio.Pull = GPIO_PULLUP; } else { gpio.Pull = GPIO_PULLDOWN; } } /* NOTE: Errata ES0125: STM32L100x6/8/B, STM32L151x6/8/B and * STM32L152x6/8/B ultra-low-power device limitations. * * 2.6.6 - Corrupted last bit of data and or CRC, received in Master * mode with delayed SCK feedback * * This driver is always using very high speed for SCK on STM32L1x */ #if defined(STM32L152xC) if (!spi->slave) { gpio.Speed = GPIO_SPEED_FREQ_VERY_HIGH; } else { gpio.Speed = gpio_speed; } #else gpio.Speed = gpio_speed; #endif rc = hal_gpio_init_stm(cfg->sck_pin, &gpio); if (rc != 0) { goto err; } #if defined(STM32L152xC) if (!spi->slave) { gpio.Speed = gpio_speed; } #endif if (!spi->slave) { gpio.Pull = GPIO_NOPULL; } else { gpio.Mode = GPIO_MODE_AF_OD; } rc = hal_gpio_init_stm(cfg->mosi_pin, &gpio); if (rc != 0) { goto err; } if (!spi->slave) { gpio.Mode = GPIO_MODE_AF_OD; } else { gpio.Mode = GPIO_MODE_AF_PP; } rc = hal_gpio_init_stm(cfg->miso_pin, &gpio); if (rc != 0) { goto err; } switch (settings->data_mode) { case HAL_SPI_MODE0: init->CLKPolarity = SPI_POLARITY_LOW; init->CLKPhase = SPI_PHASE_1EDGE; break; case HAL_SPI_MODE1: init->CLKPolarity = SPI_POLARITY_LOW; init->CLKPhase = SPI_PHASE_2EDGE; break; case HAL_SPI_MODE2: init->CLKPolarity = SPI_POLARITY_HIGH; init->CLKPhase = SPI_PHASE_1EDGE; break; case HAL_SPI_MODE3: init->CLKPolarity = SPI_POLARITY_HIGH; init->CLKPhase = SPI_PHASE_2EDGE; break; default: rc = -1; goto err; } switch (settings->data_order) { case HAL_SPI_MSB_FIRST: init->FirstBit = SPI_FIRSTBIT_MSB; break; case HAL_SPI_LSB_FIRST: init->FirstBit = SPI_FIRSTBIT_LSB; break; default: rc = -1; goto err; } switch (settings->word_size) { case HAL_SPI_WORD_SIZE_8BIT: init->DataSize = SPI_DATASIZE_8BIT; break; case HAL_SPI_WORD_SIZE_9BIT: init->DataSize = SPI_DATASIZE_16BIT; break; default: rc = -1; goto err; } rc = stm32_spi_resolve_prescaler(spi_num, settings->baudrate * 1000, &prescaler); if (rc != 0) { goto err; } init->BaudRatePrescaler = prescaler; /* Add default values */ init->Direction = SPI_DIRECTION_2LINES; init->TIMode = SPI_TIMODE_DISABLE; init->CRCCalculation = SPI_CRCCALCULATION_DISABLE; init->CRCPolynomial = 1; #ifdef SPI_NSS_PULSE_DISABLE init->NSSPMode = SPI_NSS_PULSE_DISABLE; #endif irq = stm32_resolve_spi_irq(&spi->handle); NVIC_SetPriority(irq, cfg->irq_prio); NVIC_SetVector(irq, stm32_resolve_spi_irq_handler(&spi->handle)); NVIC_EnableIRQ(irq); /* Init, Enable */ rc = HAL_SPI_Init(&spi->handle); if (rc != 0) { goto err; } if (spi->slave) { hal_spi_slave_set_def_tx_val(spi_num, 0); rc = hal_gpio_irq_init(cfg->ss_pin, spi_ss_isr, spi, HAL_GPIO_TRIG_BOTH, HAL_GPIO_PULL_UP); spi_ss_isr(spi); } __HAL_ENABLE_INTERRUPTS(sr); return (0); err: __HAL_ENABLE_INTERRUPTS(sr); return (rc); }
void HAL_SPI_MspInit(SPI_HandleTypeDef* spiHandle) { GPIO_InitTypeDef GPIO_InitStruct; if(spiHandle->Instance==SPI3) { /* USER CODE BEGIN SPI3_MspInit 0 */ /* USER CODE END SPI3_MspInit 0 */ /* SPI3 clock enable */ __HAL_RCC_SPI3_CLK_ENABLE(); /**SPI3 GPIO Configuration PC10 ------> SPI3_SCK PC11 ------> SPI3_MISO PC12 ------> SPI3_MOSI */ GPIO_InitStruct.Pin = GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF6_SPI3; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); /* SPI3 DMA Init */ /* SPI3_TX Init */ hdma_spi3_tx.Instance = DMA1_Stream5; hdma_spi3_tx.Init.Channel = DMA_CHANNEL_0; hdma_spi3_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_spi3_tx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_spi3_tx.Init.MemInc = DMA_MINC_ENABLE; hdma_spi3_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; hdma_spi3_tx.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; hdma_spi3_tx.Init.Mode = DMA_NORMAL; hdma_spi3_tx.Init.Priority = DMA_PRIORITY_MEDIUM; hdma_spi3_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; if (HAL_DMA_Init(&hdma_spi3_tx) != HAL_OK) { _Error_Handler(__FILE__, __LINE__); } __HAL_LINKDMA(spiHandle,hdmatx,hdma_spi3_tx); /* SPI3_RX Init */ hdma_spi3_rx.Instance = DMA1_Stream0; hdma_spi3_rx.Init.Channel = DMA_CHANNEL_0; hdma_spi3_rx.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_spi3_rx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_spi3_rx.Init.MemInc = DMA_MINC_ENABLE; hdma_spi3_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; hdma_spi3_rx.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; hdma_spi3_rx.Init.Mode = DMA_NORMAL; hdma_spi3_rx.Init.Priority = DMA_PRIORITY_MEDIUM; hdma_spi3_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; if (HAL_DMA_Init(&hdma_spi3_rx) != HAL_OK) { _Error_Handler(__FILE__, __LINE__); } __HAL_LINKDMA(spiHandle,hdmarx,hdma_spi3_rx); /* SPI3 interrupt Init */ HAL_NVIC_SetPriority(SPI3_IRQn, 5, 0); HAL_NVIC_EnableIRQ(SPI3_IRQn); /* USER CODE BEGIN SPI3_MspInit 1 */ /* USER CODE END SPI3_MspInit 1 */ } }
void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi) { GPIO_InitTypeDef GPIO_InitStruct; if(hspi->Instance==SPI1) { /* USER CODE BEGIN SPI1_MspInit 0 */ /* USER CODE END SPI1_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_SPI1_CLK_ENABLE(); /**SPI1 GPIO Configuration PA5 ------> SPI1_SCK PA6 ------> SPI1_MISO PA7 ------> SPI1_MOSI */ GPIO_InitStruct.Pin = ADC_SCK_SPI1_Pin|ADC_MISO_SPI1_Pin|ADC_MOSI_SPI1_Pin; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF5_SPI1; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* USER CODE BEGIN SPI1_MspInit 1 */ /* USER CODE END SPI1_MspInit 1 */ } else if(hspi->Instance==SPI2) { /* USER CODE BEGIN SPI2_MspInit 0 */ /* USER CODE END SPI2_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_SPI2_CLK_ENABLE(); /**SPI2 GPIO Configuration PB13 ------> SPI2_SCK PB14 ------> SPI2_MISO PB15 ------> SPI2_MOSI */ GPIO_InitStruct.Pin = FLASH_SCK_SPI2_Pin|FLASH_MISO_SPI2_Pin|FLASH_MOSI_SPI2_Pin; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF5_SPI2; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* USER CODE BEGIN SPI2_MspInit 1 */ /* USER CODE END SPI2_MspInit 1 */ } else if(hspi->Instance==SPI3) { /* USER CODE BEGIN SPI3_MspInit 0 */ /* USER CODE END SPI3_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_SPI3_CLK_ENABLE(); /**SPI3 GPIO Configuration PB3 ------> SPI3_SCK PB4 ------> SPI3_MISO PB5 ------> SPI3_MOSI */ GPIO_InitStruct.Pin = IAC_SCK_SPI3_Pin|IAC_MISO_SPI3_Pin|IAC_MOSI_SPI3_Pin; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF6_SPI3; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* Peripheral interrupt init */ HAL_NVIC_SetPriority(SPI3_IRQn, 5, 0); HAL_NVIC_EnableIRQ(SPI3_IRQn); /* USER CODE BEGIN SPI3_MspInit 1 */ /* USER CODE END SPI3_MspInit 1 */ } }
void enableGPIOPowerUsageAndNoiseReductions(void) { // AHB1 __HAL_RCC_BKPSRAM_CLK_ENABLE(); __HAL_RCC_DTCMRAMEN_CLK_ENABLE(); __HAL_RCC_DMA2_CLK_ENABLE(); __HAL_RCC_USB_OTG_HS_CLK_ENABLE(); __HAL_RCC_USB_OTG_HS_ULPI_CLK_ENABLE(); __HAL_RCC_GPIOA_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE(); __HAL_RCC_GPIOC_CLK_ENABLE(); __HAL_RCC_GPIOD_CLK_ENABLE(); __HAL_RCC_GPIOE_CLK_ENABLE(); __HAL_RCC_GPIOF_CLK_ENABLE(); __HAL_RCC_GPIOG_CLK_ENABLE(); __HAL_RCC_GPIOH_CLK_ENABLE(); __HAL_RCC_GPIOI_CLK_ENABLE(); #ifndef STM32F722xx __HAL_RCC_DMA2D_CLK_ENABLE(); __HAL_RCC_GPIOJ_CLK_ENABLE(); __HAL_RCC_GPIOK_CLK_ENABLE(); #endif //APB1 __HAL_RCC_TIM2_CLK_ENABLE(); __HAL_RCC_TIM3_CLK_ENABLE(); __HAL_RCC_TIM4_CLK_ENABLE(); __HAL_RCC_TIM5_CLK_ENABLE(); __HAL_RCC_TIM6_CLK_ENABLE(); __HAL_RCC_TIM7_CLK_ENABLE(); __HAL_RCC_TIM12_CLK_ENABLE(); __HAL_RCC_TIM13_CLK_ENABLE(); __HAL_RCC_TIM14_CLK_ENABLE(); __HAL_RCC_LPTIM1_CLK_ENABLE(); __HAL_RCC_SPI2_CLK_ENABLE(); __HAL_RCC_SPI3_CLK_ENABLE(); __HAL_RCC_USART2_CLK_ENABLE(); __HAL_RCC_USART3_CLK_ENABLE(); __HAL_RCC_UART4_CLK_ENABLE(); __HAL_RCC_UART5_CLK_ENABLE(); __HAL_RCC_I2C1_CLK_ENABLE(); __HAL_RCC_I2C2_CLK_ENABLE(); __HAL_RCC_I2C3_CLK_ENABLE(); __HAL_RCC_CAN1_CLK_ENABLE(); __HAL_RCC_DAC_CLK_ENABLE(); __HAL_RCC_UART7_CLK_ENABLE(); __HAL_RCC_UART8_CLK_ENABLE(); #ifndef STM32F722xx __HAL_RCC_I2C4_CLK_ENABLE(); __HAL_RCC_CAN2_CLK_ENABLE(); __HAL_RCC_CEC_CLK_ENABLE(); #endif //APB2 __HAL_RCC_TIM1_CLK_ENABLE(); __HAL_RCC_TIM8_CLK_ENABLE(); __HAL_RCC_USART1_CLK_ENABLE(); __HAL_RCC_USART6_CLK_ENABLE(); __HAL_RCC_ADC1_CLK_ENABLE(); __HAL_RCC_ADC2_CLK_ENABLE(); __HAL_RCC_ADC3_CLK_ENABLE(); __HAL_RCC_SDMMC1_CLK_ENABLE(); __HAL_RCC_SPI1_CLK_ENABLE(); __HAL_RCC_SPI4_CLK_ENABLE(); __HAL_RCC_TIM9_CLK_ENABLE(); __HAL_RCC_TIM10_CLK_ENABLE(); __HAL_RCC_TIM11_CLK_ENABLE(); __HAL_RCC_SPI5_CLK_ENABLE(); __HAL_RCC_SAI1_CLK_ENABLE(); __HAL_RCC_SAI2_CLK_ENABLE(); #ifndef STM32F722xx __HAL_RCC_SPI6_CLK_ENABLE(); #endif // // GPIO_InitTypeDef GPIO_InitStructure; // GPIO_StructInit(&GPIO_InitStructure); // GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; // default is un-pulled input // // GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All; // GPIO_InitStructure.GPIO_Pin &= ~(GPIO_Pin_11 | GPIO_Pin_12); // leave USB D+/D- alone // // GPIO_InitStructure.GPIO_Pin &= ~(GPIO_Pin_13 | GPIO_Pin_14); // leave JTAG pins alone // GPIO_Init(GPIOA, &GPIO_InitStructure); // // GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All; // GPIO_Init(GPIOB, &GPIO_InitStructure); // // GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All; // GPIO_Init(GPIOC, &GPIO_InitStructure); // GPIO_Init(GPIOD, &GPIO_InitStructure); // GPIO_Init(GPIOE, &GPIO_InitStructure); }
void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel) { struct spi_s *spiobj = SPI_S(obj); SPI_HandleTypeDef *handle = &(spiobj->handle); // Determine the SPI to use SPIName spi_mosi = (SPIName)pinmap_peripheral(mosi, PinMap_SPI_MOSI); SPIName spi_miso = (SPIName)pinmap_peripheral(miso, PinMap_SPI_MISO); SPIName spi_sclk = (SPIName)pinmap_peripheral(sclk, PinMap_SPI_SCLK); SPIName spi_ssel = (SPIName)pinmap_peripheral(ssel, PinMap_SPI_SSEL); SPIName spi_data = (SPIName)pinmap_merge(spi_mosi, spi_miso); SPIName spi_cntl = (SPIName)pinmap_merge(spi_sclk, spi_ssel); spiobj->spi = (SPIName)pinmap_merge(spi_data, spi_cntl); MBED_ASSERT(spiobj->spi != (SPIName)NC); #if defined SPI1_BASE // Enable SPI clock if (spiobj->spi == SPI_1) { __HAL_RCC_SPI1_CLK_ENABLE(); spiobj->spiIRQ = SPI1_IRQn; } #endif #if defined SPI2_BASE if (spiobj->spi == SPI_2) { __HAL_RCC_SPI2_CLK_ENABLE(); spiobj->spiIRQ = SPI2_IRQn; } #endif #if defined SPI3_BASE if (spiobj->spi == SPI_3) { __HAL_RCC_SPI3_CLK_ENABLE(); spiobj->spiIRQ = SPI3_IRQn; } #endif #if defined SPI4_BASE if (spiobj->spi == SPI_4) { __HAL_RCC_SPI4_CLK_ENABLE(); spiobj->spiIRQ = SPI4_IRQn; } #endif #if defined SPI5_BASE if (spiobj->spi == SPI_5) { __HAL_RCC_SPI5_CLK_ENABLE(); spiobj->spiIRQ = SPI5_IRQn; } #endif #if defined SPI6_BASE if (spiobj->spi == SPI_6) { __HAL_RCC_SPI6_CLK_ENABLE(); spiobj->spiIRQ = SPI6_IRQn; } #endif // Configure the SPI pins pinmap_pinout(mosi, PinMap_SPI_MOSI); pinmap_pinout(miso, PinMap_SPI_MISO); pinmap_pinout(sclk, PinMap_SPI_SCLK); spiobj->pin_miso = miso; spiobj->pin_mosi = mosi; spiobj->pin_sclk = sclk; spiobj->pin_ssel = ssel; if (ssel != NC) { pinmap_pinout(ssel, PinMap_SPI_SSEL); } else { handle->Init.NSS = SPI_NSS_SOFT; } /* Fill default value */ handle->Instance = SPI_INST(obj); handle->Init.Mode = SPI_MODE_MASTER; handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256; handle->Init.Direction = SPI_DIRECTION_2LINES; handle->Init.CLKPhase = SPI_PHASE_1EDGE; handle->Init.CLKPolarity = SPI_POLARITY_LOW; handle->Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED; handle->Init.CRCPolynomial = 7; handle->Init.DataSize = SPI_DATASIZE_8BIT; handle->Init.FirstBit = SPI_FIRSTBIT_MSB; handle->Init.TIMode = SPI_TIMODE_DISABLED; init_spi(obj); }
void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel) { // Determine the SPI to use SPIName spi_mosi = (SPIName)pinmap_peripheral(mosi, PinMap_SPI_MOSI); SPIName spi_miso = (SPIName)pinmap_peripheral(miso, PinMap_SPI_MISO); SPIName spi_sclk = (SPIName)pinmap_peripheral(sclk, PinMap_SPI_SCLK); SPIName spi_ssel = (SPIName)pinmap_peripheral(ssel, PinMap_SPI_SSEL); SPIName spi_data = (SPIName)pinmap_merge(spi_mosi, spi_miso); SPIName spi_cntl = (SPIName)pinmap_merge(spi_sclk, spi_ssel); obj->spi = (SPIName)pinmap_merge(spi_data, spi_cntl); MBED_ASSERT(obj->spi != (SPIName)NC); // Enable SPI clock if (obj->spi == SPI_1) { __HAL_RCC_SPI1_CLK_ENABLE(); } if (obj->spi == SPI_2) { __HAL_RCC_SPI2_CLK_ENABLE(); } if (obj->spi == SPI_3) { __HAL_RCC_SPI3_CLK_ENABLE(); } #if defined SPI4_BASE if (obj->spi == SPI_4) { __HAL_RCC_SPI4_CLK_ENABLE(); } #endif #if defined SPI5_BASE if (obj->spi == SPI_5) { __HAL_RCC_SPI5_CLK_ENABLE(); } #endif // Configure the SPI pins pinmap_pinout(mosi, PinMap_SPI_MOSI); pinmap_pinout(miso, PinMap_SPI_MISO); pinmap_pinout(sclk, PinMap_SPI_SCLK); // Save new values obj->bits = SPI_DATASIZE_8BIT; obj->cpol = SPI_POLARITY_LOW; obj->cpha = SPI_PHASE_1EDGE; obj->br_presc = SPI_BAUDRATEPRESCALER_256; obj->pin_miso = miso; obj->pin_mosi = mosi; obj->pin_sclk = sclk; obj->pin_ssel = ssel; if (ssel != NC) { pinmap_pinout(ssel, PinMap_SPI_SSEL); } else { obj->nss = SPI_NSS_SOFT; } init_spi(obj); }