/**
* @brief
* @param None
* @retval None
*/
ErrorStatus SPI2_DeInit()
{
if (HAL_SPI_DeInit(&SPI_Handle) != HAL_OK)
return ERROR;
else
return SUCCESS;
}
/**
* @brief SPIx error treatment function.
* @param None
* @retval None
*/
static void SPIx_Error(void)
{
/* De-initialize the SPI comunication bus */
HAL_SPI_DeInit(&SpiHandle);
/* Re-Initiaize the SPI comunication bus */
SPIx_Init();
}
/**
* @brief SPI error treatment function
* @param None
* @retval None
*/
static void SPIx_Error (void)
{
/* De-initialize the SPI communication BUS */
HAL_SPI_DeInit(&heval_Spi);
/* Re- Initiaize the SPI communication BUS */
SPIx_Init();
}
/**
* @brief SPI error treatment function.
* @param None
* @retval None
*/
void SPI1_Error (void)
{
/* De-Initialize the SPI comunication BUS */
HAL_SPI_DeInit(&SpiHandle);
/* Re-Initiaize the SPI comunication BUS */
SPI1_Init();
}
void SpiDeInit( Spi_t *obj )
{
HAL_SPI_DeInit( &obj->Spi );
GpioInit( &obj->Mosi, obj->Mosi.pin, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &obj->Miso, obj->Miso.pin, PIN_OUTPUT, PIN_PUSH_PULL, PIN_PULL_DOWN, 0 );
GpioInit( &obj->Sclk, obj->Sclk.pin, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &obj->Nss, obj->Nss.pin, PIN_OUTPUT, PIN_PUSH_PULL, PIN_PULL_UP, 1 );
}
/**
* @brief This function is implemented to deinitialize the SPI interface
* (IOs + SPI block)
* @param obj : pointer to spi_t structure
* @retval None
*/
void spi_deinit(spi_t *obj)
{
if(obj == NULL)
return;
SPI_HandleTypeDef *handle = &(obj->handle);
HAL_SPI_DeInit(handle);
#if defined SPI1_BASE
// Reset SPI and disable clock
if (handle->Instance == SPI1) {
__HAL_RCC_SPI1_FORCE_RESET();
__HAL_RCC_SPI1_RELEASE_RESET();
__HAL_RCC_SPI1_CLK_DISABLE();
}
#endif
#if defined SPI2_BASE
if (handle->Instance == SPI2) {
__HAL_RCC_SPI2_FORCE_RESET();
__HAL_RCC_SPI2_RELEASE_RESET();
__HAL_RCC_SPI2_CLK_DISABLE();
}
#endif
#if defined SPI3_BASE
if (handle->Instance == SPI3) {
__HAL_RCC_SPI3_FORCE_RESET();
__HAL_RCC_SPI3_RELEASE_RESET();
__HAL_RCC_SPI3_CLK_DISABLE();
}
#endif
#if defined SPI4_BASE
if (handle->Instance == SPI4) {
__HAL_RCC_SPI4_FORCE_RESET();
__HAL_RCC_SPI4_RELEASE_RESET();
__HAL_RCC_SPI4_CLK_DISABLE();
}
#endif
#if defined SPI5_BASE
if (handle->Instance == SPI5) {
__HAL_RCC_SPI5_FORCE_RESET();
__HAL_RCC_SPI5_RELEASE_RESET();
__HAL_RCC_SPI5_CLK_DISABLE();
}
#endif
#if defined SPI6_BASE
if (handle->Instance == SPI6) {
__HAL_RCC_SPI6_FORCE_RESET();
__HAL_RCC_SPI6_RELEASE_RESET();
__HAL_RCC_SPI6_CLK_DISABLE();
}
#endif
}
//------------------------------------------------------------------------------------------------------------------------------------------------------
void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef* handleSPI)
{
if (!Panel_ProcessingCommandFromPIC(dataSPIfromPanel))
{
HAL_SPI_DeInit(handleSPI);
HAL_SPI_Init(handleSPI);
}
SPI1->DR = Panel_NextData();
}
// ***** GP22 - Hardware Setup
uint8_t gp22_hw_setup()
{
GPIO_InitTypeDef GPIO_InitStruct;
HAL_SPI_StateTypeDef spi_status;
// Init INT-Pin
GPIO_InitStruct.Pin = GP22_INT_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
HAL_GPIO_Init(GP22_INT_PORT, &GPIO_InitStruct);
GP22_INT_CLK_ENABLE();
// Init CS-Pin
GPIO_InitStruct.Pin = GP22_CS_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
HAL_GPIO_Init(GP22_CS_PORT, &GPIO_InitStruct);
GP22_CS_CLK_ENABLE();
GP22_CS_HIGH();
// Init RESET-Pin
GPIO_InitStruct.Pin = GP22_RESET_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
HAL_GPIO_Init(GP22_RESET_PORT, &GPIO_InitStruct);
GP22_RESET_CLK_ENABLE();
GP22_RESET_LOW();
// Init SPI
hGP22_SPI.Instance = GP22_SPI;
hGP22_SPI.Init.BaudRatePrescaler = GP22_SPI_PRESCALER;
hGP22_SPI.Init.Direction = SPI_DIRECTION_2LINES;
hGP22_SPI.Init.CLKPhase = SPI_PHASE_2EDGE;
hGP22_SPI.Init.CLKPolarity = SPI_POLARITY_LOW;
hGP22_SPI.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;
hGP22_SPI.Init.CRCPolynomial = 7;
hGP22_SPI.Init.DataSize = SPI_DATASIZE_8BIT;
hGP22_SPI.Init.FirstBit = SPI_FIRSTBIT_MSB;
hGP22_SPI.Init.NSS = SPI_NSS_SOFT;
hGP22_SPI.Init.TIMode = SPI_TIMODE_DISABLED;
hGP22_SPI.Init.Mode = SPI_MODE_MASTER;
spi_status = HAL_SPI_GetState(&hGP22_SPI);
if (spi_status != HAL_SPI_STATE_RESET)
{
hal_status = HAL_SPI_DeInit(&hGP22_SPI);
}
hal_status = HAL_SPI_Init(&hGP22_SPI);
return hal_status;
}
static void Error_Handler(SPI_HandleTypeDef *hspi)
{
wTransferState = TRANSFER_ERROR;
/* reset spi */
mods_muc_set_spi1_cs(PIN_SET);
HAL_SPI_DeInit(hspi);
dbgprint("SPI Flash DeInit\r\n");
device_spi_flash_init(hspi);
dbgprint("SPI Flash Re-Init\r\n");
memset(aTxBuffer_spiFlash, 0, MAX_DMA_BUF_SIZE);
memset(aRxBuffer_spiFlash, 0, MAX_DMA_BUF_SIZE);
}
void spi_abort_asynch(spi_t *obj)
{
// diable interrupt
vIRQ_DisableIRQ(SpiIRQs[obj->spi.module]);
// clean-up
SPI_HandleTypeDef *handle = &SpiHandle[obj->spi.module];
__HAL_SPI_DISABLE(handle);
HAL_SPI_DeInit(handle);
HAL_SPI_Init(handle);
__HAL_SPI_ENABLE(handle);
}
void spi_abort_asynch(spi_t *obj)
{
struct spi_s *spiobj = SPI_S(obj);
SPI_HandleTypeDef *handle = &(spiobj->handle);
// disable interrupt
IRQn_Type irq_n = spiobj->spiIRQ;
NVIC_ClearPendingIRQ(irq_n);
NVIC_DisableIRQ(irq_n);
// clean-up
__HAL_SPI_DISABLE(handle);
HAL_SPI_DeInit(handle);
HAL_SPI_Init(handle);
__HAL_SPI_ENABLE(handle);
}
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 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)
{
}
}
uint8_t gp22_spi_reconfig(SPI_HandleTypeDef *hspi)
{
HAL_SPI_DeInit(hspi);
hspi->Instance = GP22_SPI;
hspi->Init.BaudRatePrescaler = GP22_SPI_PRESCALER;
hspi->Init.Direction = SPI_DIRECTION_2LINES;
hspi->Init.CLKPhase = SPI_PHASE_2EDGE;
hspi->Init.CLKPolarity = SPI_POLARITY_LOW;
hspi->Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;
hspi->Init.CRCPolynomial = 7;
hspi->Init.DataSize = SPI_DATASIZE_8BIT;
hspi->Init.FirstBit = SPI_FIRSTBIT_MSB;
hspi->Init.NSS = SPI_NSS_SOFT;
hspi->Init.TIMode = SPI_TIMODE_DISABLED;
hspi->Init.Mode = SPI_MODE_MASTER;
return HAL_SPI_Init(hspi);
}
/**
* @brief Set LIS3DSH Initialization.
* @param LIS3DSH_Config_Struct: pointer to a LIS3DSH_Config_TypeDef structure
* that contains the configuration setting for the LIS3DSH.
* @retval None
*/
void LIS3DSH_Init(LIS3DSH_InitTypeDef *LIS3DSH_InitStruct)
{
uint8_t ctrl = 0x00;
/* Configure the low level interface ---------------------------------------*/
/* SPI configuration -------------------------------------------------------*/
__HAL_RCC_SPI1_CLK_ENABLE();
HAL_SPI_DeInit(&SpiHandle);
SpiHandle.Instance = SPI1;
SpiHandle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
SpiHandle.Init.Direction = SPI_DIRECTION_2LINES;
SpiHandle.Init.CLKPhase = SPI_PHASE_1EDGE;
SpiHandle.Init.CLKPolarity = SPI_POLARITY_LOW;
SpiHandle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;
SpiHandle.Init.CRCPolynomial = 7;
SpiHandle.Init.DataSize = SPI_DATASIZE_8BIT;
SpiHandle.Init.FirstBit = SPI_FIRSTBIT_MSB;
SpiHandle.Init.NSS = SPI_NSS_SOFT;
SpiHandle.Init.TIMode = SPI_TIMODE_DISABLED;
SpiHandle.Init.Mode = SPI_MODE_MASTER;
if (HAL_SPI_Init(&SpiHandle) != HAL_OK) {printf ("ERROR: Error in initialising SPI1 \n");};
__HAL_SPI_ENABLE(&SpiHandle);
/* Configure MEMS: data rate, update mode and axes */
ctrl = (uint8_t) (LIS3DSH_InitStruct->Power_Mode_Output_DataRate | \
LIS3DSH_InitStruct->Continous_Update | \
LIS3DSH_InitStruct->Axes_Enable);
/* Write value to MEMS CTRL_REG4 regsister */
LIS3DSH_Write(&ctrl, LIS3DSH_CTRL_REG4, 1);
/* Configure MEMS: Anti-aliasing filter, full scale, self test */
ctrl = (uint8_t) (LIS3DSH_InitStruct->AA_Filter_BW | \
LIS3DSH_InitStruct->Full_Scale | \
LIS3DSH_InitStruct->Self_Test);
/* Write value to MEMS CTRL_REG5 regsister */
LIS3DSH_Write(&ctrl, LIS3DSH_CTRL_REG5, 1);
}
Spi::~Spi() {
HAL_SPI_DeInit(&_spi);
HAL_NVIC_DisableIRQ(irqMap[_bus]);
spiMap[_bus] = NULL; // mark unused
}
void processCommand(){
uint32_t lengthTxData = 0;
uint32_t addr = 0;
uint32_t i;
uint32_t temp;
//At minimun resent length of trame and command name (minimun header)
//Data_buffer_Transmit[0] = 0; //Low byte of length set in sendAndWaitIfNotReadyAndValidCommand before send
//Data_buffer_Transmit[1] = 0; // High byte of length set in sendAndWaitIfNotReadyAndValidCommand before send
Data_buffer_Transmit[2] = rx_raw_Frame[2]; //at minimum, answer is Low byte of command
Data_buffer_Transmit[3] = rx_raw_Frame[3]; //at minimum, answer is Hight byte of command
switch (lowHighByteToInt(rx_raw_Frame[2],rx_raw_Frame[3]) ){
case FPGA_COMMAND :
receiveRawDataFromFPGABySPI[2] = LOBYTE(FPGA_DATA);
receiveRawDataFromFPGABySPI[3] = HIBYTE(FPGA_DATA);
HAL_SPI_Receive_DMA(&hspi1, *(&receiveRawDataFromFPGABySPI) + 4, 8186 ); //Offset + 4 lenght & command type
lengthTxData = lowHighByteToInt(rx_raw_Frame[0],rx_raw_Frame[1]); //resend same length to receive the answer of SPI COMMAND
//Cs low to start spi
HAL_GPIO_WritePin(GPIOC,GPIO_PIN_9,0);
HAL_SPI_Transmit_DMA(&hspi3,*(&rx_raw_Frame)+4, lengthTxData-4);
break;
case LOOPBACK :
//Copy frame in tx buffer to send the same thing just a loopback for testing purpose
memcpy (Data_buffer_Transmit,rx_raw_Frame,rx_raw_FrameLen);
mustValidCommandAfterSend = 1;
sendUSB(Data_buffer_Transmit,rx_raw_FrameLen);
//endProcessCommandAllowReceiveAgain();
//sendAndWaitIfNotReady(rx_raw_FrameLen);
break;
case LED1 :
Data_buffer_Transmit[4] = rx_raw_Frame[4]; //resend value of led
lengthTxData = 4+1; //increment length because send a value of led
HAL_GPIO_WritePin(GPIOA,GPIO_PIN_9,rx_raw_Frame[4] & 1 ); //Change value of led
//sendAndWaitIfNotReadyAndValidCommand(lengthTxData);
//If you don't want answer just
endProcessCommandAllowReceiveAgain();
break;
case LED2 :
Data_buffer_Transmit[4] = rx_raw_Frame[4] ; //resend value of led
lengthTxData = 4 + 1; //increment length because send a value of led
HAL_GPIO_WritePin(GPIOA,GPIO_PIN_10,rx_raw_Frame[4] & 1 );//Change value of led
//sendAndWaitIfNotReadyAndValidCommand(lengthTxData);
//If you don't want answer just
endProcessCommandAllowReceiveAgain();
break;
case START_FPGA :
HAL_SPI_DeInit(&hspi2);
//Nce FPGA enable
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,0);
//short pulse nconfig on release reconfigure fpga
//HAL_GPIO_WritePin(GPIOC,GPIO_PIN_0,0);
Delay(1000);
HAL_GPIO_WritePin(GPIOC,GPIO_PIN_0,1);
Delay(5000);
//Restart SPI1 to receive data from FPGA
__SPI1_RELEASE_RESET();
MX_SPI1_Init();
endProcessCommandAllowReceiveAgain();
break;
case STOP_FPGA :
//Stop SPI1 ( receive data from FPGA)
//To avoid some problem, when reset fpga (upload) 100ns pulse generate fake edge and shift (1bit) the reveived data
__SPI1_FORCE_RESET();
//HAL_SPI_MspDeInit(&hspi1);
//Nce FPGA disable
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,1);
//nconfig on release reconfigure fpga
HAL_GPIO_WritePin(GPIOC,GPIO_PIN_0,0);
Delay(5000); //wait to be sure that the fpga was stopped
MX_SPI2_Init();
sFLASH_READID(); //Must read ID to wake up the memory
Delay(5000);
//HAL_SPI_MspInit(&hspi1);
endProcessCommandAllowReceiveAgain();
break;
case ERASE_FIRMWARE :
Data_buffer_Transmit[4] = 1;
lengthTxData = 4 + 1; //increment length because send a value (1=ok)
//sFLASH_ERASE_BULK(); //slow replaced by just erasing 2 sectors
sFLASH_ERASE();
mustValidCommandAfterSend = 1;
sendUSB(Data_buffer_Transmit,lengthTxData);
break;
case READ_PAGE_FIRMWARE :
if (rx_raw_Frame[6] <= 31) {//Just check number of page if not less than 31 do nothing
lengthTxData = (uint32_t)rx_raw_Frame[6] * 256;
Data_buffer_Transmit[4] = rx_raw_Frame[4]; //low byte Number of the first page
Data_buffer_Transmit[5] = rx_raw_Frame[5]; //high byte Number of the first page
Data_buffer_Transmit[6] = rx_raw_Frame[6]; //Nb of page
addr=lowHighByteToInt(rx_raw_Frame[4],rx_raw_Frame[5])*256;
sFLASH_Read(*(&Data_buffer_Transmit)+7,addr,lengthTxData);
mustValidCommandAfterSend = 1;
sendUSB(Data_buffer_Transmit,lengthTxData+7);
}else{
Data_buffer_Transmit[2] = LOBYTE(COMMAND_NOT_FOUND);
Data_buffer_Transmit[3] = HIBYTE(COMMAND_NOT_FOUND);
mustValidCommandAfterSend = 1;
sendUSB(Data_buffer_Transmit,4);
}
break;
case WRITE_PAGE_FIRMWARE :
//Data_buffer_Transmit[4] = rx_raw_Frame[4]; //low byte Number of the first page
//Data_buffer_Transmit[5] = rx_raw_Frame[5]; //high byte Number of the first page
//Data_buffer_Transmit[6] = rx_raw_Frame[6]; //Nb of page (31 max)
addr=lowHighByteToInt(rx_raw_Frame[4],rx_raw_Frame[5])*256;
for (int i=0;i< rx_raw_Frame[6];i++){
sFLASH_WritePage(*(&rx_raw_Frame)+7+i*256,addr+i*256,256);
}
endProcessCommandAllowReceiveAgain();
break;
case GET_VERSION_NUMBER :
lengthTxData = 18;
memcpy(&Data_buffer_Transmit[4],&versionNumber,lengthTxData);
mustValidCommandAfterSend = 1;
sendUSB(Data_buffer_Transmit,lengthTxData+4);
break;
default:
//mustValidCommandAfterSend = 1;
//sendAndWaitIfNotReady(lengthTxData);
//If you don't want answer just
endProcessCommandAllowReceiveAgain();
}
}
void spi_free(spi_t *obj)
{
struct spi_s *spiobj = SPI_S(obj);
SPI_HandleTypeDef *handle = &(spiobj->handle);
DEBUG_PRINTF("spi_free\r\n");
__HAL_SPI_DISABLE(handle);
HAL_SPI_DeInit(handle);
#if defined SPI1_BASE
// Reset SPI and disable clock
if (spiobj->spi == SPI_1) {
__HAL_RCC_SPI1_FORCE_RESET();
__HAL_RCC_SPI1_RELEASE_RESET();
__HAL_RCC_SPI1_CLK_DISABLE();
}
#endif
#if defined SPI2_BASE
if (spiobj->spi == SPI_2) {
__HAL_RCC_SPI2_FORCE_RESET();
__HAL_RCC_SPI2_RELEASE_RESET();
__HAL_RCC_SPI2_CLK_DISABLE();
}
#endif
#if defined SPI3_BASE
if (spiobj->spi == SPI_3) {
__HAL_RCC_SPI3_FORCE_RESET();
__HAL_RCC_SPI3_RELEASE_RESET();
__HAL_RCC_SPI3_CLK_DISABLE();
}
#endif
#if defined SPI4_BASE
if (spiobj->spi == SPI_4) {
__HAL_RCC_SPI4_FORCE_RESET();
__HAL_RCC_SPI4_RELEASE_RESET();
__HAL_RCC_SPI4_CLK_DISABLE();
}
#endif
#if defined SPI5_BASE
if (spiobj->spi == SPI_5) {
__HAL_RCC_SPI5_FORCE_RESET();
__HAL_RCC_SPI5_RELEASE_RESET();
__HAL_RCC_SPI5_CLK_DISABLE();
}
#endif
#if defined SPI6_BASE
if (spiobj->spi == SPI_6) {
__HAL_RCC_SPI6_FORCE_RESET();
__HAL_RCC_SPI6_RELEASE_RESET();
__HAL_RCC_SPI6_CLK_DISABLE();
}
#endif
// Configure GPIOs
pin_function(spiobj->pin_miso, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
pin_function(spiobj->pin_mosi, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
pin_function(spiobj->pin_sclk, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
if (handle->Init.NSS != SPI_NSS_SOFT) {
pin_function(spiobj->pin_ssel, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
}
}
void spi_free(spi_t *obj) {
SpiHandle.Instance = (SPI_TypeDef *)(obj->spi);
HAL_SPI_DeInit(&SpiHandle);
}
void spiInitDevice(SPIDevice device)
{
static SPI_InitTypeDef spiInit;
spiDevice_t *spi = &(spiHardwareMap[device]);
#ifdef SDCARD_SPI_INSTANCE
if (spi->dev == SDCARD_SPI_INSTANCE) {
spi->leadingEdge = true;
}
#endif
#ifdef RX_SPI_INSTANCE
if (spi->dev == RX_SPI_INSTANCE) {
spi->leadingEdge = true;
}
#endif
// Enable SPI clock
RCC_ClockCmd(spi->rcc, ENABLE);
RCC_ResetCmd(spi->rcc, ENABLE);
IOInit(IOGetByTag(spi->sck), OWNER_SPI, RESOURCE_SPI_SCK, device + 1);
IOInit(IOGetByTag(spi->miso), OWNER_SPI, RESOURCE_SPI_MISO, device + 1);
IOInit(IOGetByTag(spi->mosi), OWNER_SPI, RESOURCE_SPI_MOSI, device + 1);
#if defined(STM32F3) || defined(STM32F4) || defined(STM32F7)
IOConfigGPIOAF(IOGetByTag(spi->sck), SPI_IO_AF_CFG, spi->af);
IOConfigGPIOAF(IOGetByTag(spi->miso), SPI_IO_AF_CFG, spi->af);
IOConfigGPIOAF(IOGetByTag(spi->mosi), SPI_IO_AF_CFG, spi->af);
if (spi->nss) {
IOConfigGPIOAF(IOGetByTag(spi->nss), SPI_IO_CS_CFG, spi->af);
}
#endif
#if defined(STM32F10X)
IOConfigGPIO(IOGetByTag(spi->sck), SPI_IO_AF_SCK_CFG);
IOConfigGPIO(IOGetByTag(spi->miso), SPI_IO_AF_MISO_CFG);
IOConfigGPIO(IOGetByTag(spi->mosi), SPI_IO_AF_MOSI_CFG);
if (spi->nss) {
IOConfigGPIO(IOGetByTag(spi->nss), SPI_IO_CS_CFG);
}
#endif
SPI_HandleTypeDef Handle;
Handle.Instance = spi->dev;
// Init SPI hardware
HAL_SPI_DeInit(&Handle);
spiInit.Mode = SPI_MODE_MASTER;
spiInit.Direction = SPI_DIRECTION_2LINES;
spiInit.DataSize = SPI_DATASIZE_8BIT;
spiInit.NSS = SPI_NSS_SOFT;
spiInit.FirstBit = SPI_FIRSTBIT_MSB;
spiInit.CRCPolynomial = 7;
spiInit.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
spiInit.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
spiInit.TIMode = SPI_TIMODE_DISABLED;
if (spi->leadingEdge) {
spiInit.CLKPolarity = SPI_POLARITY_LOW;
spiInit.CLKPhase = SPI_PHASE_1EDGE;
}
else {
spiInit.CLKPolarity = SPI_POLARITY_HIGH;
spiInit.CLKPhase = SPI_PHASE_2EDGE;
}
Handle.Init = spiInit;
#ifdef STM32F303xC
// Configure for 8-bit reads.
SPI_RxFIFOThresholdConfig(spi->dev, SPI_RxFIFOThreshold_QF);
#endif
if (HAL_SPI_Init(&Handle) == HAL_OK)
{
spiHandle[device].Handle = Handle;
if (spi->nss) {
IOHi(IOGetByTag(spi->nss));
}
}
}
/*********************************************************************
* @fn SPI1_DeInit
*
* @brief
*
* @param None
*
* @return void
*/
void SPI1_DeInit( void )
{
HAL_SPI_DeInit(&SpiHandle);
SPI1_DeMspInit(&SpiHandle);
}
void DevSPI::deInit()
{
__HAL_SPI_DISABLE( spi );
HAL_SPI_DeInit( spi );
last_rc = HAL_OK; last_err = 0;
}
