wtorek, 11 października 2016

[20] STM32F4 - Akcelerometr LIS3DSH

Ten post chciałbym poświęcić na opis programowania akcelerometru LIS3DSH, który został zamontowany na nowszych płytkach Discovery.

Komunikacja, tak samo jak dla LIS302DL, odbywa się za pomocą I2C bądź SPI. Ja wykorzystam ten drugi sposób.

Programowanie:


Poniżej przedstawiam zestaw wykorzystywanych rejestrów:

  1. #define LIS3DSH_ID                          0x3F
  2. #define LIS3DSH_WHO_I_AM                    0x0F
  4. #define LIS3DSH_CTRL_REG4                   0x20
  5. #define LIS3DSH_CTRL_REG1                   0x21
  6. #define LIS3DSH_CTRL_REG2                   0x22
  7. #define LIS3DSH_CTRL_REG3                   0x23
  8. #define LIS3DSH_CTRL_REG5                   0x24
  9. #define LIS3DSH_CTRL_REG6                   0x25
  10. #define LIS3DSH_OUT_X_L                     0x28
  11. #define LIS3DSH_OUT_X_H                     0x29
  12. #define LIS3DSH_OUT_Y_L                     0x2A
  13. #define LIS3DSH_OUT_Y_H                     0x2B
  14. #define LIS3DSH_OUT_Z_L                     0x2C
  15. #define LIS3DSH_OUT_Z_H                     0x2D
  17. #define LIS3DSH_SENSI_0_06G                 0.06
  18. #define LIS3DSH_SENSI_0_12G                 0.12
  19. #define LIS3DSH_SENSI_0_18G                 0.18
  20. #define LIS3DSH_SENSI_0_24G                 0.24
  21. #define LIS3DSH_SENSIY_0_73G                0.73
  23. #define LIS3DSH_DATARATE_100                ((uint8_t)0x60)
  25. #define LIS3DSH_FULLSCALE_2                 ((uint8_t)0x00)
  26. #define LIS3DSH_FULLSCALE_4                 ((uint8_t)0x08)
  27. #define LIS3DSH_FULLSCALE_6                 ((uint8_t)0x10)
  28. #define LIS3DSH_FULLSCALE_8                 ((uint8_t)0x18)
  29. #define LIS3DSH_FULLSCALE_16                ((uint8_t)0x20)
  30. #define LIS3DSH_FULLSCALE_SELECTION         ((uint8_t)0x38)
  32. #define LIS3DSH_FILTER_BW_800               ((uint8_t)0x00)
  33. #define LIS3DSH_FILTER_BW_400               ((uint8_t)0x40)
  34. #define LIS3DSH_FILTER_BW_200               ((uint8_t)0x80)
  35. #define LIS3DSH_FILTER_BW_50                ((uint8_t)(0x80 | 0x40))
  36. #define LIS3DSH_SELFTEST_NORMAL             ((uint8_t)0x00)
  37. #define LIS3DSH_XYZ_ENABLE                  ((uint8_t)0x07)
  38. #define LIS3DSH_SERINTER_4WIRE              ((uint8_t)0x00)
  39. #define LIS3DSH_SM_ENABLE                   ((uint8_t)0x01)
  40. #define LIS3DSH_SM_DISABLE                  ((uint8_t)0x00)


Poniżej część odpowiadająca za ustawienie sposobu transmisji oraz włączenia portów. Akcelerometr jest podłączony do SPI1, PA7 - MOSI, PA6 - MISO, PA5 SCK.

  1. void LIS3DSH_INT_SPI(void)
  2. {
  3.     GPIO_InitTypeDef GPIO_InitStruct;
  4.     SPI_InitTypeDef SPI_InitStruct;
  5.    
  6.     RCC_AHB1PeriphClockCmd(LIS3DSH_CS_RCC, ENABLE); //Zegar dla CS
  7.     RCC_AHB1PeriphClockCmd(LIS3DSH_SPI_PIN_CLOCK, ENABLE); 
  8.     RCC->APB2ENR |= RCC_APB2ENR_SPI1EN;             //Zegar dla SPI1
  9.     _DSB();
  11.     GPIO_InitStruct.GPIO_Pin = LIS3DSH_MISO | LIS3DSH_MOSI | LIS3DSH_SCK;
  12.     GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
  13.     GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
  14.     GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
  15.     GPIO_InitStruct.GPIO_Speed = GPIO_Speed_25MHz;
  16.     GPIO_Init(LIS3DSH_SPI_PORT, &GPIO_InitStruct);
  18.     SPI_StructInit(&SPI_InitStruct);
  19.     SPI_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_32;
  20.     SPI_InitStruct.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  21.     SPI_InitStruct.SPI_DataSize = SPI_DataSize_8b;
  22.     SPI_InitStruct.SPI_FirstBit = SPI_FirstBit_MSB;
  23.     SPI_InitStruct.SPI_Mode = SPI_Mode_Master;
  24.    
  25.     SPIx->CR1 &= ~SPI_CR1_SPE;          //Wylaczenie SPI
  26.     SPI_Init(SPIx, &SPI_InitStruct);    //Inicjalizacja SPI
  27.     SPIx->CR1 |= SPI_CR1_SPE;           //Wlaczenie SPI
  28.    
  29.     GPIO_InitStruct.GPIO_Pin = LIS3DSH_CS_PIN;
  30.     GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;
  31.     GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
  32.     GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
  33.     GPIO_InitStruct.GPIO_Speed = GPIO_Speed_25MHz;
  35.     GPIO_Init(LIS3DSH_CS_PORT, &GPIO_InitStruct);
  37.     LIS3DSH_CS_HIGH;
  38. }

Teraz czas na funkcje pozwalające na transmisję danych po interfejsie I2C:

  1. void LIS3DSH_WRITE_SPI(uint8_t* data, uint8_t addr, uint8_t count) {
  2.     LIS3DSH_CS_LOW;
  3.    
  4.     SPI_SEND(LIS3DSH_SPI, addr);    //Przeslanie adresu
  5.     /* Send data */
  6.     SPI_WRIIE_MULTI(LIS302DL_LIS3DSH_SPI, data, count); //Przeslanie danych
  7.    
  8.     LIS3DSH_CS_HIGH;
  9. }
  11. void LIS3DSH_READ_SPI(uint8_t* data, uint8_t addr, uint8_t count) {
  12.     LIS3DSH_CS_LOW;
  13.    
  14.     addr |= 0x80;
  15.    
  16.     SPI_SEND(LIS3DSH_SPI, addr);
  17.     SPI_READ_MULTI(LIS3DSH_SPI, data, 0x00, count);
  18.    
  19.     LIS3DSH_CS_HIGH;
  20. }
  22. uint8_t SPI_SEND(SPI_TypeDef* SPIx, uint8_t data) {
  23.     SPIx->DR = data;
  24.     while (((SPIx)->SR & (SPI_SR_TXE | SPI_SR_RXNE)) == 0 || ((SPIx)->SR & SPI_SR_BSY))
  25.     return SPIx->DR;
  26. }
  28. void SPI_SEND_MULTI(SPI_TypeDef* SPIx, uint8_t* dataOut, uint8_t* dataIn, uint16_t count) {
  29.     uint16_t count;
  30.     for (count = 0; count < count; count++) {
  31.         SPIx->DR = dataOut[i];
  32.         while (((SPIx)->SR & (SPI_SR_TXE | SPI_SR_RXNE)) == 0 || ((SPIx)->SR & SPI_SR_BSY))
  33.         dataIn[i] = SPIx->DR;
  34.     }
  35. }
  37. void SPI_READ_MULTI(SPI_TypeDef* SPIx, uint8_t* dataIn, uint8_t dummy, uint16_t count) {
  38.     uint8_t i;
  39.     for (i = 0; i < count; i++) {
  40.         SPIx->DR = dummy;
  41.         while (((SPIx)->SR & (SPI_SR_TXE | SPI_SR_RXNE)) == 0 || ((SPIx)->SR & SPI_SR_BSY))
  42.         dataIn[i] = SPIx->DR;
  43.     }
  44. }

Funkcja ustawiająca i sprawdzająca czy parametry zostały odpowiednio ustawione:

  1. uint8_t LIS3DSH_CHECK_ON(void)
  2. {
  3.     uint8_t id_lis;
  5.     Delayms(10);
  6.     LIS3DSH_INIT_SPI();
  7.     LIS3DSH_INT_ReadSPI(&id_lis, LIS3DSH_WHO_I_AM, 1);
  8.     if (id_lis == LIS3DSH_ID) {
  9.         return id_lis;
  10.     }
  11.    
  12.     return 0;
  13. }

Poniższa funkcja pozwala na ustawienie parametrów takich jak czułość oraz wybranie filtru:

  1. uint8_t LIS3DSH_SET_PARAMETERS(uint8_t sensitivity, uint8_t filter) {
  2.     uint8_t tmpreg;
  3.     uint16_t temp;
  4.     float sensitivity_set;
  6.     LIS3DSH_INIT_SPI();
  7.     Delayms(10);
  8.    
  9.     temp = (uint16_t) (LIS3DSH_DATARATE_100 | LIS3DSH_XYZ_ENABLE);
  10.     temp |= (uint16_t) (LIS3DSH_SERIALINTERFACE_4WIRE | LIS3DSH_SELFTEST_NORMAL);  
  12.     if (sensitivity == LIS3DSH_Sensitivity_2G) {
  13.         temp |= (uint16_t) (LIS3DSH_FULLSCALE_2);
  14.         sensitivity_set = LIS3DSH_SENSITIVITY_0_06G;
  15.     }
  16.     else if (Sensitivity == TM_LIS3DSH_Sensitivity_4G) {
  17.         temp |= (uint16_t) (LIS3DSH_FULLSCALE_4);
  18.         sensitivity_set = LIS3DSH_SENSITIVITY_0_12G;
  19.     }
  20.     else if (Sensitivity == TM_LIS3DSH_Sensitivity_6G) {
  21.         temp |= (uint16_t) (LIS3DSH_FULLSCALE_6);
  22.         sensitivity_set = LIS3DSH_SENSITIVITY_0_18G;
  23.     }
  24.     else if (Sensitivity == TM_LIS3DSH_Sensitivity_8G) {
  25.         temp |= (uint16_t) (LIS3DSH_FULLSCALE_8);
  26.         sensitivity_set = LIS3DSH_SENSITIVITY_0_24G;
  27.     }
  28.     else if (Sensitivity == TM_LIS3DSH_Sensitivity_16G) {
  29.         temp |= (uint16_t) (LIS3DSH_FULLSCALE_16);
  30.         sensitivity_set = LIS3DSH_SENSITIVITY_0_73G;
  31.     }
  32.     else { return 1; }
  33.    
  34.     if (Filter == LIS3DSH_Filter_800Hz) { temp |= (uint16_t)(LIS3DSH_FILTER_BW_800 << 8); }
  35.     else if (Filter == LIS3DSH_Filter_400Hz) { temp |= (uint16_t)(LIS3DSH_FILTER_BW_400 << 8); }
  36.     else if (Filter == LIS3DSH_Filter_200Hz) { temp |= (uint16_t)(LIS3DSH_FILTER_BW_200 << 8); }
  37.     else if (Filter == LIS3DSH_Filter_50Hz) { temp |= (uint16_t)(LIS3DSH_FILTER_BW_50 << 8); }
  38.     else { return 2; }
  39.    
  40.     tmpreg = (uint8_t)(temp);
  42.     LIS3DSH_WRITE_SPI(&tmpreg, LIS3DSH_CTRL_REG4, 1);
  44.     tmpreg = (uint8_t)(temp>>8);
  46.     LIS3DSH_WRITE_SPI(&tmpreg, LIS3DSH_CTRL_REG5, 1);
  48.     return 0;
  49. }

W tej funkcji sprawdzane są parametry podane z tymi zdeklarowanymi w define. Gdy odpowiedni zostanie znaleziony to zostaje on wprowadzony do rejestru,

Ostatnia z funkcji pozwoli na odczytanie wartości z poszczególnych osi:

  1. typedef struct {
  2.     int16_t X;
  3.     int16_t Y;
  4.     int16_t Z;
  5. } DATA_FROM_AXES_LIS3DSH_t;
  7. void LIS3DSH_READ_DATA(TM_LIS302DL_LIS3DSH_t *DAT_FROM_AXCES_STRUCT) {
  8.     int8_t buffer[6];
  10.     LIS3DSH_READ_SPI((uint8_t*)&buffer[0], LIS3DSH_OUT_X_L, 1);
  11.     LIS3DSH_READ_SPI((uint8_t*)&buffer[1], LIS3DSH_OUT_X_H, 1);
  12.     LIS3DSH_READ_SPI((uint8_t*)&buffer[2], LIS3DSH_OUT_Y_L, 1);
  13.     LIS3DSH_READ_PI((uint8_t*)&buffer[3], LIS3DSH_OUT_Y_H, 1);
  14.     LIS3DSH_READ_SPI((uint8_t*)&buffer[4], LIS3DSH_OUT_Z_L, 1);
  15.     LIS3DSH_READ_SPI((uint8_t*)&buffer[5], LIS3DSH_OUT_Z_H, 1);
  16.    
  17.     DAT_FROM_AXCES_STRUCT->X = (int16_t)((buffer[1] << 8) + buffer[0]) * set_sensitivity;
  18.     DAT_FROM_AXCES_STRUCT->Y = (int16_t)((buffer[3] << 8) + buffer[2]) * set_sensitivity;
  19.     DAT_FROM_AXCES_STRUCT->Z = (int16_t)((buffer[5] << 8) + buffer[4]) * set_sensitivity;
  20. }

Dane są wprowadzane do struktury i odczytywane z odpowiednich rejestrów, jeden dla bitów niższych oraz jeden dla bitów wyższych. Są one następnie wprowadzane do bufora i odpowiednio przekształcane do danych w strukturze.

Funkcje są wywoływane w następującej kolejności, na samym początku inicjalizacja wszystkich potrzebnych pinów oraz SPI potem wprowadzane są dane dotyczące filtru oraz czułości. Później zostaje już tylko odczytywanie danych z układu i przetworzenie ich zgodnie ze swoimi wymaganiami. Dane są zapisane bezpośrednio w strukturze. 
Autor: o
Etykiety: ,