git.itanic.dy.fi Git - BME280_driver/blob - selftest/bme280_selftest.c

   1 /**\mainpage
   2  * Copyright (C) 2018 - 2019 Bosch Sensortec GmbH
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are met:
   6  *
   7  * Redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer.
   9  *
  10  * Redistributions in binary form must reproduce the above copyright
  11  * notice, this list of conditions and the following disclaimer in the
  12  * documentation and/or other materials provided with the distribution.
  13  *
  14  * Neither the name of the copyright holder nor the names of the
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  19  * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  * DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
  23  * OR CONTRIBUTORS BE LIABLE FOR ANY
  24  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
  25  * OR CONSEQUENTIAL DAMAGES(INCLUDING, BUT NOT LIMITED TO,
  26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  29  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  31  * ANY WAY OUT OF THE USE OF THIS
  32  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
  33  *
  34  * The information provided is believed to be accurate and reliable.
  35  * The copyright holder assumes no responsibility
  36  * for the consequences of use
  37  * of such information nor for any infringement of patents or
  38  * other rights of third parties which may result from its use.
  39  * No license is granted by implication or otherwise under any patent or
  40  * patent rights of the copyright holder.
  41  *
  42  * File     bme280_selftest.c
  43  * Date     08 Mar 2019
  44  * Version  3.3.6
  45  *
  46  */
  47
  48 #include "bme280_selftest.h"
  49
  50 #define BME280_CRC_DATA_ADDR   UINT8_C(0xE8)
  51 #define BME280_CRC_DATA_LEN    UINT8_C(1)
  52 #define BME280_CRC_CALIB1_ADDR UINT8_C(0x88)
  53 #define BME280_CRC_CALIB1_LEN  UINT8_C(26)
  54 #define BME280_CRC_CALIB2_ADDR UINT8_C(0xE1)
  55 #define BME280_CRC_CALIB2_LEN  UINT8_C(7)
  56
  57 /*!
  58  * @brief This API calculates the CRC
  59  *
  60  * @param[in] mem_values : reg_data parameter to calculate CRC
  61  * @param[in] mem_length : Parameter to calculate CRC
  62  *
  63  * @return Result of API execution status
  64  * @retval zero -> Success / +ve value -> Warning / -ve value -> Error
  65  */
  66 static uint8_t crc_calculate(uint8_t *mem_values, uint8_t mem_length);
  67
  68 /*!
  69  * @brief This API reads the stored CRC and then compare with calculated CRC
  70  *
  71  * @param[in] dev : Structure instance of bme280_dev.
  72  *
  73  * @return Result of API execution status
  74  * @retval zero -> self test success / +ve value -> warning(self test fail)
  75  */
  76 int8_t bme280_crc_selftest(const struct bme280_dev *dev)
  77 {
  78     int8_t rslt;
  79     uint8_t reg_addr;
  80     uint8_t reg_data[64];
  81     uint8_t stored_crc = 0;
  82     uint8_t calculated_crc = 0;
  83
  84     /* Read stored crc value from register */
  85     reg_addr = BME280_CRC_DATA_ADDR;
  86     rslt = bme280_get_regs(reg_addr, reg_data, BME280_CRC_DATA_LEN, dev);
  87     if (rslt == BME280_OK)
  88     {
  89         stored_crc = reg_data[0];
  90
  91         /* Calculated CRC value with calibration register */
  92         reg_addr = BME280_CRC_CALIB1_ADDR;
  93         rslt = bme280_get_regs(reg_addr, &reg_data[0], BME280_CRC_CALIB1_LEN, dev);
  94         if (rslt == BME280_OK)
  95         {
  96             reg_addr = BME280_CRC_CALIB2_ADDR;
  97             rslt = bme280_get_regs(reg_addr, &reg_data[BME280_CRC_CALIB1_LEN], BME280_CRC_CALIB2_LEN, dev);
  98             if (rslt == BME280_OK)
  99             {
 100                 calculated_crc = crc_calculate(reg_data, BME280_CRC_CALIB1_LEN + BME280_CRC_CALIB2_LEN);
 101
 102                 /* Validate CRC */
 103                 if (stored_crc == calculated_crc)
 104                 {
 105                     rslt = BME280_OK;
 106                 }
 107                 else
 108                 {
 109                     rslt = BME280_W_SELF_TEST_FAIL;
 110                 }
 111             }
 112         }
 113     }
 114
 115     return rslt;
 116 }
 117
 118 /*!
 119  * @brief This API calculates the CRC
 120  *
 121  * @param[in] mem_values : reg_data parameter to calculate CRC
 122  * @param[in] mem_length : Parameter to calculate CRC
 123  *
 124  * @return Result of API execution status
 125  * @retval zero -> Success / +ve value -> Warning / -ve value -> Error
 126  */
 127 static uint8_t crc_calculate(uint8_t *mem_values, uint8_t mem_length)
 128 {
 129     uint32_t crc_reg = 0xFF;
 130     uint8_t polynomial = 0x1D;
 131     uint8_t bitNo, index;
 132     uint8_t din = 0;
 133
 134     for (index = 0; index < mem_length; index++)
 135     {
 136         for (bitNo = 0; bitNo < 8; bitNo++)
 137         {
 138             if (((crc_reg & 0x80) > 0) != ((mem_values[index] & 0x80) > 0))
 139             {
 140                 din = 1;
 141             }
 142             else
 143             {
 144                 din = 0;
 145             }
 146
 147             /* Truncate 8th bit for crc_reg and mem_values */
 148             crc_reg = (uint32_t)((crc_reg & 0x7F) << 1);
 149             mem_values[index] = (uint8_t)((mem_values[index] & 0x7F) << 1);
 150             crc_reg = (uint32_t)(crc_reg ^ (polynomial * din));
 151         }
 152     }
 153
 154     return (uint8_t)(crc_reg ^ 0xFF);
 155 }