BMP280 send wrong values - c

Question

I try to read temperature from BMP280 but I take a wrong values. Temperature in my room approximately 22 degrees so I expect to receive approximately 2200. But my program send me 715.
I use SPI connection. CS pin is set by shift register. I am sure that it work. And this is my code:
main.c
/* USER CODE BEGIN Header */
/**
******************************************************************************
* #file : main.c
* #brief : Main program body
******************************************************************************
* #attention
*
* Copyright (c) 2022 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdio.h>
#include "func.h"
#include "BMP280.h"
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
SPI_HandleTypeDef hspi2;
UART_HandleTypeDef huart1;
/* USER CODE BEGIN PV */
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_SPI2_Init(void);
static void MX_USART1_UART_Init(void);
/* USER CODE BEGIN PFP */
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
/* USER CODE END 0 */
/**
* #brief The application entry point.
* #retval int
*/
int main(void)
{
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/* MCU Configuration--------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* USER CODE BEGIN Init */
/* USER CODE END Init */
/* Configure the system clock */
SystemClock_Config();
/* USER CODE BEGIN SysInit */
/* USER CODE END SysInit */
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_SPI2_Init();
MX_USART1_UART_Init();
/* USER CODE BEGIN 2 */
Init();
uint8_t id = 0;
BMP280_Data data;
uint8_t s[30] = {0};
uint8_t len = 0;
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
ReadId(&id);
ReadAll(&data);
len = sprintf((char *)s, "Id: %i Temperature: %li ", id, data.temp);
HAL_UART_Transmit(&huart1, s, len, 0x1000);
HAL_Delay(2000);
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
/**
* #brief System Clock Configuration
* #retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
/** Configure the main internal regulator output voltage
*/
__HAL_RCC_PWR_CLK_ENABLE();
__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE2);
/** Initializes the RCC Oscillators according to the specified parameters
* in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/** Initializes the CPU, AHB and APB buses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSE;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
{
Error_Handler();
}
}
/**
* #brief SPI2 Initialization Function
* #param None
* #retval None
*/
static void MX_SPI2_Init(void)
{
/* USER CODE BEGIN SPI2_Init 0 */
/* USER CODE END SPI2_Init 0 */
/* USER CODE BEGIN SPI2_Init 1 */
/* USER CODE END SPI2_Init 1 */
/* SPI2 parameter configuration*/
hspi2.Instance = SPI2;
hspi2.Init.Mode = SPI_MODE_MASTER;
hspi2.Init.Direction = SPI_DIRECTION_2LINES;
hspi2.Init.DataSize = SPI_DATASIZE_8BIT;
hspi2.Init.CLKPolarity = SPI_POLARITY_LOW;
hspi2.Init.CLKPhase = SPI_PHASE_1EDGE;
hspi2.Init.NSS = SPI_NSS_SOFT;
hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
hspi2.Init.CRCPolynomial = 10;
if (HAL_SPI_Init(&hspi2) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN SPI2_Init 2 */
/* USER CODE END SPI2_Init 2 */
}
/**
* #brief USART1 Initialization Function
* #param None
* #retval None
*/
static void MX_USART1_UART_Init(void)
{
/* USER CODE BEGIN USART1_Init 0 */
/* USER CODE END USART1_Init 0 */
/* USER CODE BEGIN USART1_Init 1 */
/* USER CODE END USART1_Init 1 */
huart1.Instance = USART1;
huart1.Init.BaudRate = 115200;
huart1.Init.WordLength = UART_WORDLENGTH_8B;
huart1.Init.StopBits = UART_STOPBITS_1;
huart1.Init.Parity = UART_PARITY_NONE;
huart1.Init.Mode = UART_MODE_TX_RX;
huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart1.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart1) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN USART1_Init 2 */
/* USER CODE END USART1_Init 2 */
}
/**
* #brief GPIO Initialization Function
* #param None
* #retval None
*/
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* GPIO Ports Clock Enable */
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOH_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOC, SR_OE_Pin|SR_L_Pin, GPIO_PIN_RESET);
/*Configure GPIO pins : SR_OE_Pin SR_L_Pin */
GPIO_InitStruct.Pin = SR_OE_Pin|SR_L_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
}
/* USER CODE BEGIN 4 */
/* USER CODE END 4 */
/**
* #brief This function is executed in case of error occurrence.
* #retval None
*/
void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
__disable_irq();
while (1)
{
}
/* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
* #brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* #param file: pointer to the source file name
* #param line: assert_param error line source number
* #retval None
*/
void assert_failed(uint8_t *file, uint32_t line)
{
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number,
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */
func.c
#include "func.h"
void sr(uint8_t *confBuf){
HAL_GPIO_WritePin(SR_OE_GPIO_Port, SR_OE_Pin, GPIO_PIN_SET);
HAL_Delay(1);
HAL_SPI_Transmit(&hspi2, confBuf, 2, 0x1000);
HAL_Delay(1);
HAL_GPIO_WritePin(SR_L_GPIO_Port, SR_L_Pin, GPIO_PIN_SET);
HAL_Delay(1);
HAL_GPIO_WritePin(SR_L_GPIO_Port, SR_L_Pin, GPIO_PIN_RESET);
HAL_Delay(1);
HAL_GPIO_WritePin(SR_OE_GPIO_Port, SR_OE_Pin, GPIO_PIN_RESET);
HAL_Delay(10);
}
void dc(Devices d){
uint8_t ConfBuf[2] = {0b11111111, 0b11111111};
switch(d){
case(LSM6DSL_):
ConfBuf[0] = 0b11111110;
ConfBuf[1] = 0b11101110;
break;
case(BMP280_):
ConfBuf[0] = 0b11111101;
ConfBuf[1] = 0b11111010;
break;
default:
ConfBuf[0] = 0b11111111;
ConfBuf[1] = 0b11111111;
break;
}
sr(ConfBuf);
}
void spi_read_reg(Devices d, uint8_t Reg, uint8_t *Data, uint8_t len){
for(int i = 0; i < len; i++){
Reg |= 0b10000000;
dc(d);
HAL_SPI_Transmit(&hspi2, &Reg, 1, 0x1000);
HAL_SPI_Receive(&hspi2, Data, 1, 0x1000);
dc(0);
Reg++;
Data++;
}
}
void spi_write_reg(Devices d, uint8_t Reg, uint8_t *Data, uint8_t len){
for(int i = 0; i < len; i++){
Reg &= 0b01111111;
dc(d);
HAL_SPI_Transmit(&hspi2, &Reg, 1, 0x1000);
HAL_SPI_Transmit(&hspi2, Data, 1, 0x1000);
dc(0);
Reg++;
Data++;
}
}
func.h
#ifndef FUNC_H
#define FUNC_H
#include "main.h"
extern SPI_HandleTypeDef hspi2;
typedef enum {LSM6DSL_ = 1, BMP280_} Devices;
void sr(uint8_t *confBuf);
void dc(Devices d);
void spi_read_reg(Devices d, uint8_t Reg, uint8_t *Data, uint8_t len);
void spi_write_reg(Devices d, uint8_t Reg, uint8_t *Data, uint8_t len);
#endif
bmp280.c
#include "BMP280.h"
#include <stdio.h>
void Init(){
uint8_t conf[2] = {0b00100111, 0b00100000};
spi_write_reg(BMP280_, (uint8_t)CONFIG_L_REG, conf, 2);
}
void Reset(){
uint8_t data = (uint8_t)0xB6;
spi_write_reg(BMP280_, (uint8_t)RES_REG, &data, 1);
}
void ReadId(uint8_t *id){
spi_read_reg(BMP280_, (uint8_t)ID_REG, id, 1);
}
//0x88 / 0x89 dig_T1 unsigned short
//0x8A / 0x8B dig_T2 signed short
//0x8C / 0x8D dig_T3 signed short
//0x8E / 0x8F dig_P1 unsigned short
//0x90 / 0x91 dig_P2 signed short
//0x92 / 0x93 dig_P3 signed short
//0x94 / 0x95 dig_P4 signed short
//0x96 / 0x97 dig_P5 signed short
//0x98 / 0x99 dig_P6 signed short
//0x9A / 0x9B dig_P7 signed short
//0x9C / 0x9D dig_P8 signed short
//0x9E / 0x9F dig_P9 signed short
//0xA0 / 0xA reserved reserved
void ReadV(){
uint8_t Dig_T1[2] = {0};
uint8_t Dig_T2[2] = {0};
uint8_t Dig_T3[2] = {0};
uint8_t Dig_P1[2] = {0};
uint8_t Dig_P2[2] = {0};
uint8_t Dig_P3[2] = {0};
uint8_t Dig_P4[2] = {0};
uint8_t Dig_P5[2] = {0};
uint8_t Dig_P6[2] = {0};
uint8_t Dig_P7[2] = {0};
uint8_t Dig_P8[2] = {0};
uint8_t Dig_P9[2] = {0};
uint8_t Raw_data[6] = {0};
spi_read_reg(BMP280_, DIG_T1_L_REG, Dig_T1, 2);
dig_T1 = (Dig_T1[1] << 8) | Dig_T1[0];
spi_read_reg(BMP280_, DIG_T2_L_REG, Dig_T2, 2);
dig_T2 = (Dig_T2[1] << 8) | Dig_T2[0];
spi_read_reg(BMP280_, DIG_T3_L_REG, Dig_T3, 2);
dig_T3 = (Dig_T3[1] << 8) | Dig_T3[0];
spi_read_reg(BMP280_, DIG_P1_L_REG, Dig_P1, 2);
dig_P1 = (Dig_P1[1] << 8) | Dig_P1[0];
spi_read_reg(BMP280_, DIG_P2_L_REG, Dig_P2, 2);
dig_P2 = (Dig_P2[1] << 8) | Dig_P2[0];
spi_read_reg(BMP280_, DIG_P3_L_REG, Dig_P3, 2);
dig_P3 = (Dig_P3[1] << 8) | Dig_P3[0];
spi_read_reg(BMP280_, DIG_P4_L_REG, Dig_P4, 2);
dig_P4 = (Dig_P4[1] << 8) | Dig_P4[0];
spi_read_reg(BMP280_, DIG_P5_L_REG, Dig_P5, 2);
dig_P5 = (Dig_P5[1] << 8) | Dig_P5[0];
spi_read_reg(BMP280_, DIG_P6_L_REG, Dig_P6, 2);
dig_P6 = (Dig_P6[1] << 8) | Dig_P6[0];
spi_read_reg(BMP280_, DIG_P7_L_REG, Dig_P7, 2);
dig_P7 = (Dig_P7[1] << 8) | Dig_P7[0];
spi_read_reg(BMP280_, DIG_P8_L_REG, Dig_P8, 2);
dig_P8 = (Dig_P8[1] << 8) | Dig_P8[0];
spi_read_reg(BMP280_, DIG_P9_L_REG, Dig_P9, 2);
dig_P9 = (Dig_P9[1] << 8) | Dig_P9[0];
spi_read_reg(BMP280_, DATA_L_REG, &Raw_data[0], 1);
spi_read_reg(BMP280_, DATA_L_REG+1, &Raw_data[1], 1);
spi_read_reg(BMP280_, DATA_L_REG+2, &Raw_data[2], 1);
spi_read_reg(BMP280_, DATA_L_REG+3, &Raw_data[3], 1);
spi_read_reg(BMP280_, DATA_L_REG+4, &Raw_data[4], 1);
spi_read_reg(BMP280_, DATA_L_REG+5, &Raw_data[5], 1);
raw_temp = Raw_data[0] << 12 | Raw_data[1] << 4 | Raw_data[2]>>4;
raw_pres = Raw_data[3] << 12 | Raw_data[4] << 4 | Raw_data[5]>>4;
}
int32_t CompensateTemp(int32_t adc_T){
int32_t var1, var2, T;
var1 = ((((adc_T>>3) - ((int32_t)dig_T1<<1))) * ((int32_t)dig_T2)) >> 11;
var2 = (((((adc_T>>4) - ((int32_t)dig_T1)) * ((adc_T>>4) - ((int32_t)dig_T1))) >> 12) * ((int32_t)dig_T3)) >> 14;
t_fine = var1 + var2;
T = (t_fine * 5 + 128) >> 8;
return T;
}
int32_t CompensatePres(int32_t adc_P){
int64_t var1, var2, p;
var1 = ((int64_t)t_fine) - 128000;
var2 = var1 * var1 * (int64_t)dig_P6;
var2 = var2 + ((var1*(int64_t)dig_P5)<<17);
var2 = var2 + (((int64_t)dig_P4)<<35);
var1 = ((var1 * var1 * (int64_t)dig_P3)>>8) + ((var1 * (int64_t)dig_P2)<<12);
var1 = (((((int64_t)1)<<47)+var1))*((int64_t)dig_P1)>>33;
if(var1 == 0){
return 0; // avoid exception caused by division by zero
}
p = 1048576-adc_P;
p = (((p<<31)-var2)*3125)/var1;
var1 = (((int64_t)dig_P9) * (p>>13) * (p>>13)) >> 25;
var2 = (((int64_t)dig_P8) * p) >> 19;
p = ((p + var1 + var2) >> 8) + (((int64_t)dig_P7)<<4);
return (uint32_t)p;
}
void ReadAll(BMP280_Data *data){
ReadV();
data->raw_temp = raw_temp;
data->raw_pres = raw_pres;
data->temp = CompensateTemp(raw_temp);
data->pres = CompensatePres(raw_pres);
}
bmp280.h
#ifndef BMP280_H
#define BMP280_H
#include "func.h"
extern UART_HandleTypeDef huart1;
#define ID_REG 0xD0
#define RES_REG 0x0E
#define DIG_T1_L_REG 0x88
#define DIG_T2_L_REG 0x8A
#define DIG_T3_L_REG 0x8C
#define DIG_P1_L_REG 0x8E
#define DIG_P2_L_REG 0x90
#define DIG_P3_L_REG 0x92
#define DIG_P4_L_REG 0x94
#define DIG_P5_L_REG 0x96
#define DIG_P6_L_REG 0x98
#define DIG_P7_L_REG 0x9A
#define DIG_P8_L_REG 0x9C
#define DIG_P9_L_REG 0x9E
#define DATA_L_REG 0xF7
#define CONFIG_L_REG 0xF4
#define TEMP_DIF 0
#define TEMP_COF 4
#define RES_DIF 0
#define PRES_COF 1
//0x88 / 0x89 dig_T1 unsigned short
//0x8A / 0x8B dig_T2 signed short
//0x8C / 0x8D dig_T3 signed short
//0x8E / 0x8F dig_P1 unsigned short
//0x90 / 0x91 dig_P2 signed short
//0x92 / 0x93 dig_P3 signed short
//0x94 / 0x95 dig_P4 signed short
//0x96 / 0x97 dig_P5 signed short
//0x98 / 0x99 dig_P6 signed short
//0x9A / 0x9B dig_P7 signed short
//0x9C / 0x9D dig_P8 signed short
//0x9E / 0x9F dig_P9 signed short
//0xA0 / 0xA reserved reserved
uint16_t dig_T1;
int16_t dig_T2;
int16_t dig_T3;
uint16_t dig_P1;
int16_t dig_P2;
int16_t dig_P3;
int16_t dig_P4;
int16_t dig_P5;
int16_t dig_P6;
int16_t dig_P7;
int16_t dig_P8;
int16_t dig_P9;
int32_t t_fine;
int32_t raw_temp;
int64_t raw_pres;
typedef struct{
int32_t raw_temp;
int32_t raw_pres;
int32_t temp;
int32_t pres;
}BMP280_Data;
void Reset();
void Init();
void ReadId(uint8_t *id);
void ReadV();
void ReadAll();
int32_t CompensateTemp(int32_t adc_T);
int32_t CompensatePres(int32_t adc_P);
#endif
I use Compensate formula from BMP280 datasheet.
Please help me and sorry for my bad english.