pressure_sensor.hpp

Go to the documentation of this file.

 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  *  _____.___.                 .___                    .__.__      *
  *  \__  |   | ____   ____   __| _/___________    _____|__|  |     *
  *   /   |   |/ ___\ / ___\ / __ |\_  __ \__  \  /  ___/  |  |     *
  *   \____   / /_/  > /_/  > /_/ | |  | \// __ \_\___ \|  |  |__   *
  *   / ______\___  /\___  /\____ | |__|  (____  /____  >__|____/   *
  *   \/     /_____//_____/      \/            \/     \/            *
  *                         - Yggdrasil -                           *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  * This software can be used by students and other personal of the *
  * Bern University of Applied Sciences under the terms of the MIT  *
  * license.                                                        *
  * For other persons this software is under the terms of the GNU   *
  * General Public License version 2.                               *
  *                                                                 *
  * Copyright © 2021, Bern University of Applied Sciences.     *
  * All rights reserved.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#pragma once
 
#include <cpp/common/attributes.hpp>
#include <cpp/common/types.hpp>
#include <cpp/common/utils.hpp>
 
namespace bsp::ygg::prph {
 
 
    class PressureSensor {
    public:
        PressureSensor() = delete;
 
        static bool init() {
            u8 retries = 0;
            u8 id = 0;
            bsp::SPIA::setMode(bsp::drv::SPIMode::_3);
            do {
                bsp::SPIACE = true;
                bsp::SPIA::write<u8>(enumValue(Register::WHO_AM_I) | RequestResponse);
                id = bsp::SPIA::read<u8>();
                bsp::SPIACE = false;
                if(id == DeviceID) return true;
                retries++;
                if(retries > 10) return false;
                core::delay(1);
            } while(true);
 
        }
 
 
        static float getPressure() {
            return getSensorData().pressure;
        }
 
        static float getTemperature() {
            return getSensorData().sensorTemperature;
        }
 
    private:
 
        enum class Register : u8{
            INTERRUPT_CFG   = 0x0B,     
            THS_P_L         = 0x0C,     
            THS_P_H         = 0x0D,     
            WHO_AM_I        = 0x0F,     
            CTRL_REG1       = 0x10,     
            CTRL_REG2       = 0x11,     
            CTRL_REG3       = 0x12,     
            FIFO_CTRL       = 0x14,     
            REF_P_XL        = 0x15,     
            REF_P_L         = 0x16,     
            REF_P_H         = 0x17,     
            RPDS_L          = 0x18,     
            RPDS_H          = 0x19,     
            RES_CONF        = 0x1A,     
            INT_SOURCE      = 0x25,     
            FIFO_STATUS     = 0x26,     
            STATUS          = 0x27,     
            PRESS_OUT_XL    = 0x28,     
            PRESS_OUT_L     = 0x29,     
            PRESS_OUT_H     = 0x2A,     
            TEMP_OUT_L      = 0x2B,     
            TEMP_OUT_H      = 0x2C,     
            LPFP_RES        = 0x33,     
        };
 
        struct ControlRegister2 {
            u8 ONE_SHOT     : 1;    
            u8 Reserved0    : 1;    
            u8 SWRESET      : 1;    
            u8 I2C_DIS      : 1;    
            u8 IF_ADD_INC   : 1;    
            u8 STOP_ON_FTH  : 1;    
            u8 FIFO_EN      : 1;    
            u8 BOOT         : 1;    
        };
        static_assert (sizeof(ControlRegister2) == sizeof(u8), "Control register 2 definition wrong");
 
        struct SensorData {
            float pressure;             
            float sensorTemperature;    
        };
 
        constexpr static inline u8 RequestResponse = 0x80;      
        constexpr static inline u8 DeviceID = 0xb1;             
        constexpr static inline u8 ConversionDone = 0x01;       
 
        static u8 readRegister(Register reg) {
            bsp::SPIACE = true;
            bsp::SPIA::write<u8>(enumValue(reg) | RequestResponse);
            auto value = bsp::SPIA::read<u8>();
            bsp::SPIACE = false;
 
            return value;
        }
 
        static SensorData getSensorData() {
            SensorData senorData = {0};
            ControlRegister2 ctrlReg2 = { .ONE_SHOT = 1, .I2C_DIS = 0, .IF_ADD_INC = 0 };
 
            bsp::SPIACE = true;
            bsp::SPIA::write<std::array<u8,2>>({enumValue(Register::CTRL_REG2), bit_cast<u8>(ctrlReg2)});
            bsp::SPIACE = false;
 
            do{
                bsp::SPIACE = false;
                core::delay(10);
                bsp::SPIACE = true;
                bsp::SPIA::write<u8>(enumValue(Register::CTRL_REG2) | RequestResponse);
            } while((bsp::SPIA::read<u8>() & ConversionDone) == 0);
 
            {
                auto xl = readRegister(Register::PRESS_OUT_XL);
                auto l  = readRegister(Register::PRESS_OUT_L);
                auto h  = readRegister(Register::PRESS_OUT_H);
 
                senorData.pressure = static_cast<float>(xl | (l << 8) | (h << 16)) / 4096.0;
            }
 
            {
                auto l  = readRegister(Register::TEMP_OUT_L);
                auto h  = readRegister(Register::TEMP_OUT_H);
 
                senorData.sensorTemperature = static_cast<float>(l | (h << 8)) / 100;
            }
 
 
            return senorData;
        }
 
    };
 
}