DMA_HandleTypeDef* spiSetDMATransmit(DMA_Stream_TypeDef *Stream, uint32_t Channel, SPI_TypeDef *Instance, uint8_t *pData, uint16_t Size) { SPI_HandleTypeDef* hspi = &spiHandle[spiDeviceByInstance(Instance)].Handle; DMA_HandleTypeDef* hdma = &dmaHandle[spiDeviceByInstance(Instance)].Handle; hdma->Instance = Stream; hdma->Init.Channel = Channel; hdma->Init.Direction = DMA_MEMORY_TO_PERIPH; hdma->Init.PeriphInc = DMA_PINC_DISABLE; hdma->Init.MemInc = DMA_MINC_ENABLE; hdma->Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma->Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma->Init.Mode = DMA_NORMAL; hdma->Init.FIFOMode = DMA_FIFOMODE_DISABLE; hdma->Init.FIFOThreshold = DMA_FIFO_THRESHOLD_1QUARTERFULL; hdma->Init.PeriphBurst = DMA_PBURST_SINGLE; hdma->Init.MemBurst = DMA_MBURST_SINGLE; hdma->Init.Priority = DMA_PRIORITY_LOW; HAL_DMA_DeInit(hdma); HAL_DMA_Init(hdma); __HAL_DMA_ENABLE(hdma); __HAL_SPI_ENABLE(hspi); /* Associate the initialized DMA handle to the spi handle */ __HAL_LINKDMA(hspi, hdmatx, (*hdma)); // DMA TX Interrupt dmaSetHandler(DMA2_ST1_HANDLER, dmaSPIIRQHandler, NVIC_BUILD_PRIORITY(3, 0), (uint32_t)spiDeviceByInstance(Instance)); // SCB_CleanDCache_by_Addr((uint32_t) pData, Size); HAL_SPI_Transmit_DMA(hspi, pData, Size); //HAL_DMA_Start(&hdma, (uint32_t) pData, (uint32_t) &(Instance->DR), Size); return hdma; }
bool spiTransfer(SPI_TypeDef *instance, uint8_t *out, const uint8_t *in, int len) { HAL_StatusTypeDef status; #define SPI_DEFAULT_TIMEOUT 10 if(!out) // Tx only { status = HAL_SPI_Transmit(&spiHandle[spiDeviceByInstance(instance)].Handle, (uint8_t *)in, len, SPI_DEFAULT_TIMEOUT); } else if(!in) // Rx only { status = HAL_SPI_Receive(&spiHandle[spiDeviceByInstance(instance)].Handle, out, len, SPI_DEFAULT_TIMEOUT); } else // Tx and Rx { status = HAL_SPI_TransmitReceive(&spiHandle[spiDeviceByInstance(instance)].Handle, (uint8_t *)in, out, len, SPI_DEFAULT_TIMEOUT); } if( status != HAL_OK) spiTimeoutUserCallback(instance); return true; }
void spiSetDivisor(SPI_TypeDef *instance, uint16_t divisor) { SPI_HandleTypeDef *Handle = &spiHandle[spiDeviceByInstance(instance)].Handle; if (HAL_SPI_DeInit(Handle) == HAL_OK) { } switch (divisor) { case 2: Handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2; break; case 4: Handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4; break; case 8: Handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8; break; case 16: Handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16; break; case 32: Handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32; break; case 64: Handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64; break; case 128: Handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128; break; case 256: Handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256; break; } if (HAL_SPI_Init(Handle) == HAL_OK) { } }
void spiSetDivisor(SPI_TypeDef *instance, uint16_t divisor) { SPIDevice device = spiDeviceByInstance(instance); if (HAL_SPI_DeInit(&spiHardwareMap[device].hspi) == HAL_OK) { } switch (divisor) { case 2: spiHardwareMap[device].hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2; break; case 4: spiHardwareMap[device].hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4; break; case 8: spiHardwareMap[device].hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8; break; case 16: spiHardwareMap[device].hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16; break; case 32: spiHardwareMap[device].hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32; break; case 64: spiHardwareMap[device].hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64; break; case 128: spiHardwareMap[device].hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128; break; case 256: spiHardwareMap[device].hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256; break; } if (HAL_SPI_Init(&spiHardwareMap[device].hspi) == HAL_OK) { } }
void rxSpiDeviceInit(rx_spi_type_e spiType) { static bool hardwareInitialised = false; if (hardwareInitialised) { return; } #ifdef USE_RX_SOFTSPI if (spiType == RX_SPI_SOFTSPI) { useSoftSPI = true; softSpiInit(&softSPIDevice); } const SPIDevice rxSPIDevice = SOFT_SPIDEV_1; #else UNUSED(spiType); const SPIDevice rxSPIDevice = spiDeviceByInstance(RX_SPI_INSTANCE); IOInit(IOGetByTag(IO_TAG(RX_NSS_PIN)), OWNER_SPI, RESOURCE_SPI_CS, rxSPIDevice + 1); #endif // USE_RX_SOFTSPI #if defined(STM32F10X) RCC_AHBPeriphClockCmd(RX_NSS_GPIO_CLK_PERIPHERAL, ENABLE); RCC_AHBPeriphClockCmd(RX_CE_GPIO_CLK_PERIPHERAL, ENABLE); #endif #ifdef RX_CE_PIN // CE as OUTPUT IOInit(IOGetByTag(IO_TAG(RX_CE_PIN)), OWNER_RX_SPI, RESOURCE_RX_CE, rxSPIDevice + 1); #if defined(STM32F10X) IOConfigGPIO(IOGetByTag(IO_TAG(RX_CE_PIN)), SPI_IO_CS_CFG); #elif defined(STM32F3) || defined(STM32F4) IOConfigGPIOAF(IOGetByTag(IO_TAG(RX_CE_PIN)), SPI_IO_CS_CFG, 0); #endif RX_CE_LO(); #endif // RX_CE_PIN DISABLE_RX(); #ifdef RX_SPI_INSTANCE spiSetDivisor(RX_SPI_INSTANCE, SPI_CLOCK_STANDARD); #endif hardwareInitialised = true; }
DMA_HandleTypeDef* spiSetDMATransmit(DMA_Stream_TypeDef *Stream, uint32_t Channel, SPI_TypeDef *Instance, uint8_t *pData, uint16_t Size) { SPIDevice device = spiDeviceByInstance(Instance); spiHardwareMap[device].hdma.Instance = Stream; spiHardwareMap[device].hdma.Init.Channel = Channel; spiHardwareMap[device].hdma.Init.Direction = DMA_MEMORY_TO_PERIPH; spiHardwareMap[device].hdma.Init.PeriphInc = DMA_PINC_DISABLE; spiHardwareMap[device].hdma.Init.MemInc = DMA_MINC_ENABLE; spiHardwareMap[device].hdma.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; spiHardwareMap[device].hdma.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; spiHardwareMap[device].hdma.Init.Mode = DMA_NORMAL; spiHardwareMap[device].hdma.Init.FIFOMode = DMA_FIFOMODE_DISABLE; spiHardwareMap[device].hdma.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_1QUARTERFULL; spiHardwareMap[device].hdma.Init.PeriphBurst = DMA_PBURST_SINGLE; spiHardwareMap[device].hdma.Init.MemBurst = DMA_MBURST_SINGLE; spiHardwareMap[device].hdma.Init.Priority = DMA_PRIORITY_LOW; HAL_DMA_DeInit(&spiHardwareMap[device].hdma); HAL_DMA_Init(&spiHardwareMap[device].hdma); __HAL_DMA_ENABLE(&spiHardwareMap[device].hdma); __HAL_SPI_ENABLE(&spiHardwareMap[device].hspi); /* Associate the initialized DMA handle to the spi handle */ __HAL_LINKDMA(&spiHardwareMap[device].hspi, hdmatx, spiHardwareMap[device].hdma); // DMA TX Interrupt dmaSetHandler(spiHardwareMap[device].dmaIrqHandler, dmaSPIIRQHandler, NVIC_BUILD_PRIORITY(3, 0), (uint32_t)device); //HAL_CLEANCACHE(pData,Size); // And Transmit HAL_SPI_Transmit_DMA(&spiHardwareMap[device].hspi, pData, Size); return &spiHardwareMap[device].hdma; }
void pgResetFn_flashConfig(flashConfig_t *flashConfig) { flashConfig->csTag = IO_TAG(FLASH_CS_PIN); flashConfig->spiDevice = SPI_DEV_TO_CFG(spiDeviceByInstance(FLASH_SPI_INSTANCE)); }
void spiResetErrorCounter(SPI_TypeDef *instance) { SPIDevice device = spiDeviceByInstance(instance); if (device != SPIINVALID) spiHardwareMap[device].errorCount = 0; }
DMA_HandleTypeDef* dmaHandleByInstance(SPI_TypeDef *instance) { return &dmaHandle[spiDeviceByInstance(instance)].Handle; }
SPI_HandleTypeDef* spiHandleByInstance(SPI_TypeDef *instance) { return &spiHandle[spiDeviceByInstance(instance)].Handle; }
SPI_HandleTypeDef* spiHandleByInstance(SPI_TypeDef *instance) { return &spiHardwareMap[spiDeviceByInstance(instance)].hspi; }
DMA_HandleTypeDef* dmaHandleByInstance(SPI_TypeDef *instance) { return &spiHardwareMap[spiDeviceByInstance(instance)].hdma; }
void pgResetFn_barometerConfig(barometerConfig_t *barometerConfig) { barometerConfig->baro_sample_count = 21; barometerConfig->baro_noise_lpf = 600; barometerConfig->baro_cf_vel = 985; barometerConfig->baro_hardware = BARO_DEFAULT; // For backward compatibility; ceate a valid default value for bus parameters // // 1. If DEFAULT_BARO_xxx is defined, use it. // 2. Determine default based on USE_BARO_xxx // a. Precedence is in the order of popularity; BMP280, MS5611 then BMP085, then // b. If SPI variant is specified, it is likely onboard, so take it. #if !(defined(DEFAULT_BARO_SPI_BMP280) || defined(DEFAULT_BARO_BMP280) || defined(DEFAULT_BARO_SPI_MS5611) || defined(DEFAULT_BARO_MS5611) || defined(DEFAULT_BARO_BMP085) || defined(DEFAULT_BARO_SPI_LPS) || defined(DEFAULT_BARO_SPI_QMP6988) || defined(DEFAULT_BARO_QMP6988)) #if defined(USE_BARO_BMP280) || defined(USE_BARO_SPI_BMP280) #if defined(USE_BARO_SPI_BMP280) #define DEFAULT_BARO_SPI_BMP280 #else #define DEFAULT_BARO_BMP280 #endif #elif defined(USE_BARO_MS5611) || defined(USE_BARO_SPI_MS5611) #if defined(USE_BARO_SPI_MS5611) #define DEFAULT_BARO_SPI_MS5611 #else #define DEFAULT_BARO_MS5611 #endif #elif defined(USE_BARO_QMP6988) || defined(USE_BARO_SPI_QMP6988) #if defined(USE_BARO_SPI_QMP6988) #define DEFAULT_BARO_SPI_QMP6988 #else #define DEFAULT_BARO_QMP6988 #endif #elif defined(USE_BARO_SPI_LPS) #define DEFAULT_BARO_SPI_LPS #elif defined(DEFAULT_BARO_BMP085) #define DEFAULT_BARO_BMP085 #endif #endif #if defined(DEFAULT_BARO_SPI_BMP280) || defined(DEFAULT_BARO_SPI_MS5611) || defined(DEFAULT_BARO_SPI_QMP6988) || defined(DEFAULT_BARO_SPI_LPS) barometerConfig->baro_bustype = BUSTYPE_SPI; barometerConfig->baro_spi_device = SPI_DEV_TO_CFG(spiDeviceByInstance(BARO_SPI_INSTANCE)); barometerConfig->baro_spi_csn = IO_TAG(BARO_CS_PIN); barometerConfig->baro_i2c_device = I2C_DEV_TO_CFG(I2CINVALID); barometerConfig->baro_i2c_address = 0; #elif defined(DEFAULT_BARO_MS5611) || defined(DEFAULT_BARO_BMP280) || defined(DEFAULT_BARO_BMP085)||defined(DEFAULT_BARO_QMP6988) // All I2C devices shares a default config with address = 0 (per device default) barometerConfig->baro_bustype = BUSTYPE_I2C; barometerConfig->baro_i2c_device = I2C_DEV_TO_CFG(BARO_I2C_INSTANCE); barometerConfig->baro_i2c_address = 0; barometerConfig->baro_spi_device = SPI_DEV_TO_CFG(SPIINVALID); barometerConfig->baro_spi_csn = IO_TAG_NONE; #else barometerConfig->baro_hardware = BARO_NONE; barometerConfig->baro_bustype = BUSTYPE_NONE; barometerConfig->baro_i2c_device = I2C_DEV_TO_CFG(I2CINVALID); barometerConfig->baro_i2c_address = 0; barometerConfig->baro_spi_device = SPI_DEV_TO_CFG(SPIINVALID); barometerConfig->baro_spi_csn = IO_TAG_NONE; #endif }