73 #define __SensorTile_BSP_VERSION_MAIN (0x01) 74 #define __SensorTile_BSP_VERSION_SUB1 (0x00) 75 #define __SensorTile_BSP_VERSION_SUB2 (0x00) 76 #define __SensorTile_BSP_VERSION_RC (0x00) 77 #define __SensorTile_BSP_VERSION ((__SensorTile_BSP_VERSION_MAIN << 24)\ 78 |(__SensorTile_BSP_VERSION_SUB1 << 16)\ 79 |(__SensorTile_BSP_VERSION_SUB2 << 8 )\ 80 |(__SensorTile_BSP_VERSION_RC)) 90 static uint32_t I2C_SENSORTILE_Timeout = SENSORTILE_I2C_ONBOARD_SENSORS_TIMEOUT_MAX;
91 static I2C_HandleTypeDef I2C_SENSORTILE_Handle;
92 static SPI_HandleTypeDef SPI_Sensor_Handle;
94 SPI_HandleTypeDef SPI_SD_Handle;
95 DMA_HandleTypeDef hdma_tx;
98 GPIO_TypeDef* GPIO_PORT[LEDn] = {LED1_GPIO_PORT, LEDSWD_GPIO_PORT};
100 const uint32_t GPIO_PIN[LEDn] = {LED1_PIN, LEDSWD_PIN};
102 uint32_t SpixTimeout = SENSORTILE_SD_SPI_TIMEOUT_MAX;
127 void SPI_Read(SPI_HandleTypeDef* xSpiHandle, uint8_t *val);
128 void SPI_Read_nBytes(SPI_HandleTypeDef* xSpiHandle, uint8_t *val, uint16_t nBytesToRead );
129 void SPI_Write(SPI_HandleTypeDef* xSpiHandle, uint8_t val);
135 HAL_StatusTypeDef
SD_IO_WriteCmd(uint8_t Cmd, uint32_t Arg, uint8_t Crc, uint8_t Response);
161 return __SensorTile_BSP_VERSION;
174 GPIO_InitTypeDef GPIO_InitStruct;
177 __HAL_RCC_PWR_CLK_ENABLE();
178 HAL_PWREx_EnableVddIO2();
181 LEDx_GPIO_CLK_ENABLE(Led);
184 GPIO_InitStruct.Pin = GPIO_PIN[Led];
185 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
186 GPIO_InitStruct.Pull = GPIO_NOPULL;
187 GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
189 HAL_GPIO_Init(GPIO_PORT[Led], &GPIO_InitStruct);
223 HAL_GPIO_WritePin(GPIO_PORT[Led], GPIO_PIN[Led], GPIO_PIN_SET);
225 else if (Led == LEDSWD)
227 HAL_GPIO_WritePin(GPIO_PORT[Led], GPIO_PIN[Led], GPIO_PIN_RESET);
245 HAL_GPIO_WritePin(GPIO_PORT[Led], GPIO_PIN[Led], GPIO_PIN_RESET);
247 else if (Led == LEDSWD)
249 HAL_GPIO_WritePin(GPIO_PORT[Led], GPIO_PIN[Led], GPIO_PIN_SET);
265 HAL_GPIO_TogglePin(GPIO_PORT[Led], GPIO_PIN[Led]);
278 return COMPONENT_ERROR;
295 GPIO_InitTypeDef GPIO_InitStruct;
297 if(HAL_SPI_GetState( &SPI_Sensor_Handle) == HAL_SPI_STATE_RESET )
299 SENSORTILE_SENSORS_SPI_CLK_ENABLE();
300 SENSORTILE_SENSORS_SPI_GPIO_CLK_ENABLE();
302 GPIO_InitStruct.Pin = SENSORTILE_SENSORS_SPI_MOSI_Pin;
303 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
304 GPIO_InitStruct.Pull = GPIO_PULLUP;
305 GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
306 GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;
307 HAL_GPIO_Init(SENSORTILE_SENSORS_SPI_Port, &GPIO_InitStruct);
309 GPIO_InitStruct.Pin = SENSORTILE_SENSORS_SPI_SCK_Pin;
310 GPIO_InitStruct.Pull = GPIO_PULLUP;
311 HAL_GPIO_Init(SENSORTILE_SENSORS_SPI_Port, &GPIO_InitStruct);
313 SPI_Sensor_Handle.Instance = SENSORTILE_SENSORS_SPI;
314 SPI_Sensor_Handle.Init.Mode = SPI_MODE_MASTER;
315 SPI_Sensor_Handle.Init.Direction = SPI_DIRECTION_1LINE;
316 SPI_Sensor_Handle.Init.DataSize = SPI_DATASIZE_8BIT;
317 SPI_Sensor_Handle.Init.CLKPolarity = SPI_POLARITY_HIGH;
318 SPI_Sensor_Handle.Init.CLKPhase = SPI_PHASE_2EDGE;
319 SPI_Sensor_Handle.Init.NSS = SPI_NSS_SOFT;
320 SPI_Sensor_Handle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
322 SPI_Sensor_Handle.Init.FirstBit = SPI_FIRSTBIT_MSB;
323 SPI_Sensor_Handle.Init.TIMode = SPI_TIMODE_DISABLED;
324 SPI_Sensor_Handle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;
325 SPI_Sensor_Handle.Init.CRCPolynomial = 7;
326 SPI_Sensor_Handle.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
327 SPI_Sensor_Handle.Init.NSSPMode = SPI_NSS_PULSE_DISABLED;
328 HAL_SPI_Init(&SPI_Sensor_Handle);
330 SPI_1LINE_TX(&SPI_Sensor_Handle);
331 __HAL_SPI_ENABLE(&SPI_Sensor_Handle);
336 uint8_t Sensor_IO_SPI_CS_Init_All(
void)
338 GPIO_InitTypeDef GPIO_InitStruct;
341 HAL_GPIO_WritePin(SENSORTILE_LSM6DSM_SPI_CS_Port, SENSORTILE_LSM6DSM_SPI_CS_Pin, GPIO_PIN_SET);
342 HAL_GPIO_WritePin(SENSORTILE_LSM303AGR_X_SPI_CS_Port, SENSORTILE_LSM303AGR_X_SPI_CS_Pin, GPIO_PIN_SET);
343 HAL_GPIO_WritePin(SENSORTILE_LSM303AGR_M_SPI_CS_Port, SENSORTILE_LSM303AGR_M_SPI_CS_Pin, GPIO_PIN_SET);
344 HAL_GPIO_WritePin(SENSORTILE_LPS22HB_SPI_CS_Port, SENSORTILE_LPS22HB_SPI_CS_Pin, GPIO_PIN_SET);
346 GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
347 GPIO_InitStruct.Pull = GPIO_NOPULL;
348 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
350 SENSORTILE_LSM6DSM_SPI_CS_GPIO_CLK_ENABLE();
351 GPIO_InitStruct.Pin = SENSORTILE_LSM6DSM_SPI_CS_Pin;
352 HAL_GPIO_Init(SENSORTILE_LSM6DSM_SPI_CS_Port, &GPIO_InitStruct);
353 HAL_GPIO_WritePin(SENSORTILE_LSM6DSM_SPI_CS_Port, SENSORTILE_LSM6DSM_SPI_CS_Pin, GPIO_PIN_SET);
355 SENSORTILE_LSM303AGR_X_SPI_CS_GPIO_CLK_ENABLE();
356 GPIO_InitStruct.Pin = SENSORTILE_LSM303AGR_X_SPI_CS_Pin;
357 HAL_GPIO_Init(SENSORTILE_LSM303AGR_X_SPI_CS_Port, &GPIO_InitStruct);
358 HAL_GPIO_WritePin(SENSORTILE_LSM303AGR_X_SPI_CS_Port, SENSORTILE_LSM303AGR_X_SPI_CS_Pin, GPIO_PIN_SET);
360 SENSORTILE_LSM303AGR_M_SPI_CS_GPIO_CLK_ENABLE();
361 GPIO_InitStruct.Pin = SENSORTILE_LSM303AGR_M_SPI_CS_Pin;
362 HAL_GPIO_Init(SENSORTILE_LSM303AGR_M_SPI_CS_Port, &GPIO_InitStruct);
363 HAL_GPIO_WritePin(SENSORTILE_LSM303AGR_M_SPI_CS_Port, SENSORTILE_LSM303AGR_M_SPI_CS_Pin, GPIO_PIN_SET);
365 SENSORTILE_LPS22HB_SPI_CS_GPIO_CLK_ENABLE();
366 GPIO_InitStruct.Pin = SENSORTILE_LPS22HB_SPI_CS_Pin;
367 HAL_GPIO_Init(SENSORTILE_LPS22HB_SPI_CS_Port, &GPIO_InitStruct);
368 HAL_GPIO_WritePin(SENSORTILE_LPS22HB_SPI_CS_Port, SENSORTILE_LPS22HB_SPI_CS_Pin, GPIO_PIN_SET);
373 uint8_t Sensor_IO_SPI_CS_Init(
void *handle)
375 GPIO_InitTypeDef GPIO_InitStruct;
376 DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
378 GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
379 GPIO_InitStruct.Pull = GPIO_NOPULL;
380 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
382 switch(ctx->spiDevice)
385 SENSORTILE_LSM6DSM_SPI_CS_GPIO_CLK_ENABLE();
386 GPIO_InitStruct.Pin = SENSORTILE_LSM6DSM_SPI_CS_Pin;
388 HAL_GPIO_WritePin(SENSORTILE_LSM6DSM_SPI_CS_Port, SENSORTILE_LSM6DSM_SPI_CS_Pin, GPIO_PIN_SET);
389 HAL_GPIO_Init(SENSORTILE_LSM6DSM_SPI_CS_Port, &GPIO_InitStruct);
392 SENSORTILE_LSM303AGR_X_SPI_CS_GPIO_CLK_ENABLE();
393 GPIO_InitStruct.Pin = SENSORTILE_LSM303AGR_X_SPI_CS_Pin;
395 HAL_GPIO_WritePin(SENSORTILE_LSM303AGR_X_SPI_CS_Port, SENSORTILE_LSM303AGR_X_SPI_CS_Pin, GPIO_PIN_SET);
396 HAL_GPIO_Init(SENSORTILE_LSM303AGR_X_SPI_CS_Port, &GPIO_InitStruct);
399 SENSORTILE_LSM303AGR_M_SPI_CS_GPIO_CLK_ENABLE();
400 GPIO_InitStruct.Pin = SENSORTILE_LSM303AGR_M_SPI_CS_Pin;
402 HAL_GPIO_WritePin(SENSORTILE_LSM303AGR_M_SPI_CS_Port, SENSORTILE_LSM303AGR_M_SPI_CS_Pin, GPIO_PIN_SET);
403 HAL_GPIO_Init(SENSORTILE_LSM303AGR_M_SPI_CS_Port, &GPIO_InitStruct);
406 SENSORTILE_LPS22HB_SPI_CS_GPIO_CLK_ENABLE();
407 GPIO_InitStruct.Pin = SENSORTILE_LPS22HB_SPI_CS_Pin;
409 HAL_GPIO_WritePin(SENSORTILE_LPS22HB_SPI_CS_Port, SENSORTILE_LPS22HB_SPI_CS_Pin, GPIO_PIN_SET);
410 HAL_GPIO_Init(SENSORTILE_LPS22HB_SPI_CS_Port, &GPIO_InitStruct);
413 return COMPONENT_NOT_IMPLEMENTED;
427 uint8_t
Sensor_IO_Write(
void *handle, uint8_t WriteAddr, uint8_t *pBuffer, uint16_t nBytesToWrite )
430 DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
435 if ( nBytesToWrite > 1 )
437 if (ctx->who_am_i == HTS221_WHO_AM_I_VAL)
447 if ( nBytesToWrite > 1 )
449 switch(ctx->who_am_i)
451 case LSM303AGR_ACC_WHO_AM_I: WriteAddr |= 0x40;
break;
452 case LSM303AGR_MAG_WHO_AM_I:
break;
459 return COMPONENT_ERROR;
474 DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
490 uint8_t
Sensor_IO_Read(
void *handle, uint8_t ReadAddr, uint8_t *pBuffer, uint16_t nBytesToRead )
493 DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
498 if ( nBytesToRead > 1 )
500 if (ctx->who_am_i == HTS221_WHO_AM_I_VAL)
508 if(ctx->ifType == 1 )
510 if ( nBytesToRead > 1 ) {
511 switch(ctx->who_am_i)
513 case LSM303AGR_ACC_WHO_AM_I: ReadAddr |= 0x40;
break;
514 case LSM303AGR_MAG_WHO_AM_I:
break;
521 return COMPONENT_ERROR;
534 uint8_t
Sensor_IO_I2C_Read(
void *handle, uint8_t ReadAddr, uint8_t *pBuffer, uint16_t nBytesToRead )
537 DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
558 Sensor_IO_SPI_CS_Enable(handle);
560 SPI_Write(&SPI_Sensor_Handle, WriteAddr);
562 for(i=0;i<nBytesToWrite;i++)
564 SPI_Write(&SPI_Sensor_Handle, pBuffer[i]);
567 Sensor_IO_SPI_CS_Disable(handle);
581 uint8_t
Sensor_IO_SPI_Read(
void *handle, uint8_t ReadAddr, uint8_t *pBuffer, uint16_t nBytesToRead )
584 Sensor_IO_SPI_CS_Enable(handle);
587 SPI_Write(&SPI_Sensor_Handle, ReadAddr | 0x80);
590 __HAL_SPI_DISABLE(&SPI_Sensor_Handle);
591 SPI_1LINE_RX(&SPI_Sensor_Handle);
594 if(nBytesToRead > 1U)
600 SPI_Read(&SPI_Sensor_Handle, pBuffer);
604 Sensor_IO_SPI_CS_Disable(handle);
607 SPI_1LINE_TX(&SPI_Sensor_Handle);
608 __HAL_SPI_ENABLE(&SPI_Sensor_Handle);
614 uint8_t Sensor_IO_SPI_CS_Enable(
void *handle)
616 DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
618 switch(ctx->spiDevice)
621 HAL_GPIO_WritePin(SENSORTILE_LSM6DSM_SPI_CS_Port, SENSORTILE_LSM6DSM_SPI_CS_Pin, GPIO_PIN_RESET);
624 HAL_GPIO_WritePin(SENSORTILE_LSM303AGR_X_SPI_CS_Port, SENSORTILE_LSM303AGR_X_SPI_CS_Pin, GPIO_PIN_RESET);
627 HAL_GPIO_WritePin(SENSORTILE_LSM303AGR_M_SPI_CS_Port, SENSORTILE_LSM303AGR_M_SPI_CS_Pin, GPIO_PIN_RESET);
630 HAL_GPIO_WritePin(SENSORTILE_LPS22HB_SPI_CS_Port, SENSORTILE_LPS22HB_SPI_CS_Pin, GPIO_PIN_RESET);
636 uint8_t Sensor_IO_SPI_CS_Disable(
void *handle)
638 DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
640 switch(ctx->spiDevice)
643 HAL_GPIO_WritePin(SENSORTILE_LSM6DSM_SPI_CS_Port, SENSORTILE_LSM6DSM_SPI_CS_Pin, GPIO_PIN_SET);
646 HAL_GPIO_WritePin(SENSORTILE_LSM303AGR_X_SPI_CS_Port, SENSORTILE_LSM303AGR_X_SPI_CS_Pin, GPIO_PIN_SET);
649 HAL_GPIO_WritePin(SENSORTILE_LSM303AGR_M_SPI_CS_Port, SENSORTILE_LSM303AGR_M_SPI_CS_Pin, GPIO_PIN_SET);
652 HAL_GPIO_WritePin(SENSORTILE_LPS22HB_SPI_CS_Port, SENSORTILE_LPS22HB_SPI_CS_Pin, GPIO_PIN_SET);
668 GPIO_InitTypeDef GPIO_InitStructureInt2;
671 LSM6DSM_INT2_GPIO_CLK_ENABLE();
674 GPIO_InitStructureInt2.Pin = LSM6DSM_INT2_PIN;
675 GPIO_InitStructureInt2.Mode = GPIO_MODE_IT_RISING;
676 GPIO_InitStructureInt2.Speed = GPIO_SPEED_FAST;
677 GPIO_InitStructureInt2.Pull = GPIO_NOPULL;
678 HAL_GPIO_Init(LSM6DSM_INT2_GPIO_PORT, &GPIO_InitStructureInt2);
681 HAL_NVIC_SetPriority(LSM6DSM_INT2_EXTI_IRQn, 0x08, 0x00);
682 HAL_NVIC_EnableIRQ(LSM6DSM_INT2_EXTI_IRQn);
697 void SPI_Read(SPI_HandleTypeDef* xSpiHandle, uint8_t *val)
706 __HAL_SPI_ENABLE(xSpiHandle);
709 __HAL_SPI_DISABLE(xSpiHandle);
713 while ((xSpiHandle->Instance->SR & SPI_FLAG_RXNE) != SPI_FLAG_RXNE);
715 *val = *(__IO uint8_t *) &xSpiHandle->Instance->DR;
716 while ((xSpiHandle->Instance->SR & SPI_FLAG_BSY) == SPI_FLAG_BSY);
726 void SPI_Read_nBytes(SPI_HandleTypeDef* xSpiHandle, uint8_t *val, uint16_t nBytesToRead)
730 __HAL_SPI_ENABLE(xSpiHandle);
733 while (nBytesToRead > 1U)
736 if (xSpiHandle->Instance->SR & SPI_FLAG_RXNE)
739 *val = *(__IO uint8_t *) &xSpiHandle->Instance->DR;
740 val +=
sizeof(uint8_t);
751 __HAL_SPI_DISABLE(xSpiHandle);
755 while ((xSpiHandle->Instance->SR & SPI_FLAG_RXNE) != SPI_FLAG_RXNE);
757 *val = *(__IO uint8_t *) &xSpiHandle->Instance->DR;
758 while ((xSpiHandle->Instance->SR & SPI_FLAG_BSY) == SPI_FLAG_BSY);
767 void SPI_Write(SPI_HandleTypeDef* xSpiHandle, uint8_t val)
770 while ((xSpiHandle->Instance->SR & SPI_FLAG_TXE) != SPI_FLAG_TXE);
773 *((__IO uint8_t*) &xSpiHandle->Instance->DR) = val;
776 while ((xSpiHandle->Instance->SR & SPI_FLAG_FTLVL) != SPI_FTLVL_EMPTY);
777 while ((xSpiHandle->Instance->SR & SPI_FLAG_BSY) == SPI_FLAG_BSY);
791 if(HAL_I2C_GetState( &I2C_SENSORTILE_Handle) == HAL_I2C_STATE_RESET )
794 I2C_SENSORTILE_Handle.Init.Timing = I2C_SENSORTILE_TIMING_400KHZ;
796 I2C_SENSORTILE_Handle.Init.OwnAddress1 = 0x33;
797 I2C_SENSORTILE_Handle.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
798 I2C_SENSORTILE_Handle.Instance = SENSORTILE_I2C_ONBOARD_SENSORS;
802 HAL_I2C_Init( &I2C_SENSORTILE_Handle );
805 if( HAL_I2C_GetState( &I2C_SENSORTILE_Handle) == HAL_I2C_STATE_READY )
829 HAL_StatusTypeDef status = HAL_OK;
831 status = HAL_I2C_Mem_Write( &I2C_SENSORTILE_Handle, Addr, ( uint16_t )Reg, I2C_MEMADD_SIZE_8BIT, pBuffer, Size, I2C_SENSORTILE_Timeout );
834 if( status != HAL_OK )
859 HAL_StatusTypeDef status = HAL_OK;
861 status = HAL_I2C_Mem_Read( &I2C_SENSORTILE_Handle, Addr, ( uint16_t )Reg, I2C_MEMADD_SIZE_8BIT, pBuffer, Size, I2C_SENSORTILE_Timeout );
864 if( status != HAL_OK )
885 HAL_I2C_DeInit( &I2C_SENSORTILE_Handle );
899 GPIO_InitTypeDef GPIO_InitStruct;
901 RCC_PeriphCLKInitTypeDef RCC_PeriphCLKInitStruct;
904 RCC_PeriphCLKInitStruct.PeriphClockSelection = SENSORTILE_I2C_ONBOARD_SENSORS_RCC_PERIPHCLK;
905 RCC_PeriphCLKInitStruct.I2c3ClockSelection = SENSORTILE_I2C_ONBOARD_SENSORS_I2CCLKSOURCE;
906 HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
909 SENSORTILE_I2C_ONBOARD_SENSORS_SCL_SDA_GPIO_CLK_ENABLE();
912 GPIO_InitStruct.Pin = SENSORTILE_I2C_ONBOARD_SENSORS_SCL_PIN | SENSORTILE_I2C_ONBOARD_SENSORS_SDA_PIN;
913 GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
914 GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
915 GPIO_InitStruct.Pull = GPIO_PULLUP;
916 GPIO_InitStruct.Alternate = SENSORTILE_I2C_ONBOARD_SENSORS_SCL_SDA_AF;
918 HAL_GPIO_Init( SENSORTILE_I2C_ONBOARD_SENSORS_SCL_SDA_GPIO_PORT, &GPIO_InitStruct );
921 SENSORTILE_I2C_ONBOARD_SENSORS_CLK_ENABLE();
924 SENSORTILE_I2C_ONBOARD_SENSORS_FORCE_RESET();
927 SENSORTILE_I2C_ONBOARD_SENSORS_RELEASE_RESET();
930 HAL_NVIC_SetPriority(SENSORTILE_I2C_ONBOARD_SENSORS_EV_IRQn, 0, 0);
931 HAL_NVIC_EnableIRQ(SENSORTILE_I2C_ONBOARD_SENSORS_EV_IRQn);
934 HAL_NVIC_SetPriority(SENSORTILE_I2C_ONBOARD_SENSORS_ER_IRQn, 0, 0);
935 HAL_NVIC_EnableIRQ(SENSORTILE_I2C_ONBOARD_SENSORS_ER_IRQn);
947 GPIO_InitTypeDef GPIO_InitStructure;
950 __HAL_RCC_PWR_CLK_ENABLE();
951 HAL_PWREx_EnableVddIO2();
954 SENSORTILE_SD_SPI_CLK_ENABLE();
957 __HAL_RCC_DMA2_CLK_ENABLE();
962 SENSORTILE_SD_SPI_SCK_GPIO_CLK_ENABLE();
963 SENSORTILE_SD_SPI_MISO_MOSI_GPIO_CLK_ENABLE();
966 GPIO_InitStructure.Pin = SENSORTILE_SD_SPI_SCK_PIN;
967 GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
968 GPIO_InitStructure.Pull = GPIO_NOPULL;
969 GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
970 GPIO_InitStructure.Alternate = SENSORTILE_SD_SPI_SCK_AF;
971 HAL_GPIO_Init(SENSORTILE_SD_SPI_SCK_GPIO_PORT, &GPIO_InitStructure);
974 GPIO_InitStructure.Pin = (SENSORTILE_SD_SPI_MOSI_PIN);
975 GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
976 GPIO_InitStructure.Pull = GPIO_NOPULL;
977 GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
978 GPIO_InitStructure.Alternate = SENSORTILE_SD_SPI_MISO_MOSI_AF;
979 HAL_GPIO_Init(SENSORTILE_SD_SPI_MISO_MOSI_GPIO_PORT, &GPIO_InitStructure);
981 GPIO_InitStructure.Pin = (SENSORTILE_SD_SPI_MISO_PIN );
982 GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
983 GPIO_InitStructure.Pull = GPIO_PULLUP;
984 GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
985 GPIO_InitStructure.Alternate = SENSORTILE_SD_SPI_MISO_MOSI_AF;
986 HAL_GPIO_Init(SENSORTILE_SD_SPI_MISO_MOSI_GPIO_PORT, &GPIO_InitStructure);
992 hdma_tx.Instance = DMA2_Channel2;
993 hdma_tx.Init.Request = DMA_REQUEST_3;
994 hdma_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
995 hdma_tx.Init.PeriphInc = DMA_PINC_DISABLE;
996 hdma_tx.Init.MemInc = DMA_MINC_ENABLE;
997 hdma_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
998 hdma_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
999 hdma_tx.Init.Mode = DMA_NORMAL;
1000 hdma_tx.Init.Priority = DMA_PRIORITY_LOW;
1002 HAL_DMA_Init(&hdma_tx);
1005 __HAL_LINKDMA(hspi, hdmatx, hdma_tx);
1009 HAL_NVIC_SetPriority(DMA2_Channel2_IRQn, 2, 1);
1010 HAL_NVIC_EnableIRQ(DMA2_Channel2_IRQn);
1025 if(HAL_SPI_GetState(&SPI_SD_Handle) == HAL_SPI_STATE_RESET)
1027 SPI_SD_Handle.Instance = SENSORTILE_SD_SPI;
1028 SPI_SD_Handle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
1029 SPI_SD_Handle.Init.Direction = SPI_DIRECTION_2LINES;
1030 SPI_SD_Handle.Init.CLKPhase = SPI_PHASE_1EDGE;
1031 SPI_SD_Handle.Init.CLKPolarity = SPI_POLARITY_LOW;
1032 SPI_SD_Handle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;
1033 SPI_SD_Handle.Init.CRCPolynomial = 7;
1034 SPI_SD_Handle.Init.DataSize = SPI_DATASIZE_8BIT;
1035 SPI_SD_Handle.Init.FirstBit = SPI_FIRSTBIT_MSB;
1036 SPI_SD_Handle.Init.NSS = SPI_NSS_SOFT;
1037 SPI_SD_Handle.Init.TIMode = SPI_TIMODE_DISABLED;
1038 SPI_SD_Handle.Init.Mode = SPI_MODE_MASTER;
1041 HAL_SPI_Init(&SPI_SD_Handle);
1052 HAL_SPI_DeInit(&SPI_SD_Handle);
1056 if(HAL_SPI_GetState(&SPI_SD_Handle) == HAL_SPI_STATE_RESET)
1058 SPI_SD_Handle.Instance = SENSORTILE_SD_SPI;
1059 SPI_SD_Handle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
1060 SPI_SD_Handle.Init.Direction = SPI_DIRECTION_2LINES;
1061 SPI_SD_Handle.Init.CLKPhase = SPI_PHASE_1EDGE;
1062 SPI_SD_Handle.Init.CLKPolarity = SPI_POLARITY_LOW;
1063 SPI_SD_Handle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;
1064 SPI_SD_Handle.Init.CRCPolynomial = 7;
1065 SPI_SD_Handle.Init.DataSize = SPI_DATASIZE_8BIT;
1066 SPI_SD_Handle.Init.FirstBit = SPI_FIRSTBIT_MSB;
1067 SPI_SD_Handle.Init.NSS = SPI_NSS_SOFT;
1068 SPI_SD_Handle.Init.TIMode = SPI_TIMODE_DISABLED;
1069 SPI_SD_Handle.Init.Mode = SPI_MODE_MASTER;
1072 HAL_SPI_Init(&SPI_SD_Handle);
1083 HAL_StatusTypeDef status = HAL_OK;
1084 uint32_t readvalue = 0;
1085 uint32_t writevalue = 0xFFFFFFFF;
1087 status = HAL_SPI_TransmitReceive(&SPI_SD_Handle, (uint8_t*) &writevalue, (uint8_t*) &readvalue, 1, SpixTimeout);
1090 if(status != HAL_OK)
1106 HAL_StatusTypeDef status = HAL_OK;
1108 status = HAL_SPI_Transmit(&SPI_SD_Handle, (uint8_t*) &Value, 1, SpixTimeout);
1111 if(status != HAL_OK)
1126 HAL_SPI_DeInit(&SPI_SD_Handle);
1150 SENSORTILE_SD_CS_HIGH();
1154 for (counter = 0; counter <= 9; counter++)
1177 SENSORTILE_SD_CS_HIGH();
1181 for (counter = 0; counter <= 9; counter++)
1188 void SD_IO_CS_Init(
void)
1190 GPIO_InitTypeDef GPIO_InitStructure;
1193 SENSORTILE_SD_CS_GPIO_CLK_ENABLE();
1197 GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
1198 GPIO_InitStructure.Pull = GPIO_PULLUP;
1199 GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
1200 HAL_GPIO_Init(SENSORTILE_SD_CS_GPIO_PORT, &GPIO_InitStructure);
1206 void SD_IO_CS_DeInit(
void)
1208 GPIO_InitTypeDef GPIO_InitStructure;
1212 GPIO_InitStructure.Mode = GPIO_MODE_ANALOG;
1213 GPIO_InitStructure.Pull = GPIO_NOPULL;
1214 GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
1215 HAL_GPIO_Init(SENSORTILE_SD_CS_GPIO_PORT, &GPIO_InitStructure);
1240 if(HAL_SPI_Transmit_DMA(&SPI_SD_Handle, (uint8_t*)pData, Size) != HAL_OK)
1275 uint32_t n = 0x00, resp;
1279 frame[0] = (Cmd | 0x40);
1280 frame[1] = (uint8_t)(Arg >> 24);
1281 frame[2] = (uint8_t)(Arg >> 16);
1282 frame[3] = (uint8_t)(Arg >> 8);
1283 frame[4] = (uint8_t)(Arg);
1287 SENSORTILE_SD_CS_LOW();
1290 for (n = 0; n < 6; n++)
1298 }
while ((resp & 0x80) && --n);
1312 HAL_StatusTypeDef
SD_IO_WriteCmd(uint8_t Cmd, uint32_t Arg, uint8_t Crc, uint8_t Response)
1314 uint32_t counter = 0x00;
1318 frame[0] = (Cmd | 0x40);
1319 frame[1] = (uint8_t)(Arg >> 24);
1320 frame[2] = (uint8_t)(Arg >> 16);
1321 frame[3] = (uint8_t)(Arg >> 8);
1322 frame[4] = (uint8_t)(Arg);
1326 SENSORTILE_SD_CS_LOW();
1329 for (counter = 0; counter < 6; counter++)
1334 if(Response != SENSORTILE_SD_NO_RESPONSE_EXPECTED)
1349 uint32_t timeout = 0xFF0;
1377 SENSORTILE_SD_CS_HIGH();
static void I2C_SENSORTILE_Error(uint8_t Addr)
Manages error callback by re-initializing I2C.
uint8_t SD_IO_ReadByte(void)
Reads a byte from the SD.
static void SD_IO_SPI_Error(void)
SPI error treatment function.
void BSP_LED_Off(Led_TypeDef Led)
Turns selected LED Off.
void SD_IO_WriteByte(uint8_t Data)
Writes a byte on the SD.
uint32_t BSP_GetVersion(void)
This method returns the STM32446E EVAL BSP Driver revision.
static uint32_t SD_IO_SPI_Read(void)
SPI Read 4 bytes from device.
void BSP_LED_Toggle(Led_TypeDef Led)
Toggles the selected LED.
#define SENSORTILE_SD_CS_PIN
SD Control Interface pins.
void SPI_Read(SPI_HandleTypeDef *xSpiHandle, uint8_t *val)
This function reads a single byte on SPI 3-wire.
uint8_t Sensor_IO_Write(void *handle, uint8_t WriteAddr, uint8_t *pBuffer, uint16_t nBytesToWrite)
Writes a buffer to the sensor.
uint8_t Sensor_IO_Read(void *handle, uint8_t ReadAddr, uint8_t *pBuffer, uint16_t nBytesToRead)
Reads from the sensor to a buffer.
DrvStatusTypeDef Sensor_IO_SPI_Init(void)
Configures sensor SPI interface.
static void SD_IO_SPI_Init_LS(void)
Initializes SPI HAL. Low baundrate for initializazion phase.
static void SD_IO_SPI_MspInit(SPI_HandleTypeDef *hspi)
Initializes SPI MSP.
uint8_t Sensor_IO_I2C_Write(void *handle, uint8_t WriteAddr, uint8_t *pBuffer, uint16_t nBytesToWrite)
Writes a buffer to the sensor by I2C.
uint8_t SD_IO_WriteCmd_wResp(uint8_t Cmd, uint32_t Arg, uint8_t Crc)
Sends 5 bytes command to the SD card and get response.
HAL_StatusTypeDef SD_IO_WriteCmd(uint8_t Cmd, uint32_t Arg, uint8_t Crc, uint8_t Response)
Sends 5 bytes command to the SD card and get response.
This file contains definitions for SensorTile.c file.
void BSP_LED_DeInit(Led_TypeDef Led)
DeInit LEDs.
void BSP_LED_Init(Led_TypeDef Led)
Configures LEDs.
uint8_t Sensor_IO_I2C_Read(void *handle, uint8_t ReadAddr, uint8_t *pBuffer, uint16_t nBytesToRead)
Reads from the sensor to a buffer by I2C.
static uint8_t I2C_SENSORTILE_Init(void)
Configures I2C interface.
void SD_IO_WriteDummy(void)
Sends dummy byte with CS High.
void SPI_Write(SPI_HandleTypeDef *xSpiHandle, uint8_t val)
This function writes a single byte on SPI 3-wire.
static void I2C_SENSORTILE_MspInit(void)
I2C MSP Initialization.
void SPI_Read_nBytes(SPI_HandleTypeDef *xSpiHandle, uint8_t *val, uint16_t nBytesToRead)
This function reads multiple bytes on SPI 3-wire.
static void SD_IO_SPI_Write(uint8_t Value)
SPI Write a byte to device.
DrvStatusTypeDef LSM6DSM_Sensor_IO_ITConfig(void)
Configures sensor interrupts interface for LSM6DSM sensor.
DrvStatusTypeDef Sensor_IO_I2C_Init(void)
Configures sensor SPI interface.
void SD_IO_Init(void)
Initializes the SD Card and put it into StandBy State (Ready for data transfer).
uint8_t Sensor_IO_SPI_Write(void *handle, uint8_t WriteAddr, uint8_t *pBuffer, uint16_t nBytesToWrite)
Writes a buffer to the sensor.
void BSP_LED_On(Led_TypeDef Led)
Turns selected LED On.
uint8_t Sensor_IO_SPI_Read(void *handle, uint8_t ReadAddr, uint8_t *pBuffer, uint16_t nBytesToRead)
Reads a from the sensor to buffer.
static uint8_t I2C_SENSORTILE_ReadData(uint8_t Addr, uint8_t Reg, uint8_t *pBuffer, uint16_t Size)
Read a register of the device through BUS.
void SD_IO_Init_LS(void)
Initializes the SD Card and put it into StandBy State (Ready for data transfer). Low baundrate...
HAL_StatusTypeDef SD_IO_WaitResponse(uint8_t Response)
Waits response from the SD card.
static uint8_t I2C_SENSORTILE_WriteData(uint8_t Addr, uint8_t Reg, uint8_t *pBuffer, uint16_t Size)
Write data to the register of the device through BUS.
static void SD_IO_SPI_Init(void)
Initializes SPI HAL. High baundrate.
void SD_IO_WriteDMA(uint8_t *pData, uint16_t Size)
Writes a block by DMA on the SD.