499 lines
16 KiB
C++
499 lines
16 KiB
C++
/*
|
|
* SPDX-FileCopyrightText: 2024 M5Stack Technology CO LTD
|
|
*
|
|
* SPDX-License-Identifier: MIT
|
|
*/
|
|
/*
|
|
UnitTest for UnitQMP6988
|
|
*/
|
|
#include <gtest/gtest.h>
|
|
#include <Wire.h>
|
|
#include <M5Unified.h>
|
|
#include <M5UnitUnified.hpp>
|
|
#include <googletest/test_template.hpp>
|
|
#include <googletest/test_helper.hpp>
|
|
#include <unit/unit_QMP6988.hpp>
|
|
#include <chrono>
|
|
#include <cmath>
|
|
#include <random>
|
|
|
|
using namespace m5::unit::googletest;
|
|
using namespace m5::unit;
|
|
using namespace m5::unit::qmp6988;
|
|
using namespace m5::unit::qmp6988::command;
|
|
using m5::unit::types::elapsed_time_t;
|
|
|
|
const ::testing::Environment* global_fixture = ::testing::AddGlobalTestEnvironment(new GlobalFixture<400000U>());
|
|
|
|
constexpr uint32_t STORED_SIZE{8};
|
|
|
|
class TestQMP6988 : public ComponentTestBase<UnitQMP6988, bool> {
|
|
protected:
|
|
virtual UnitQMP6988* get_instance() override
|
|
{
|
|
auto ptr = new m5::unit::UnitQMP6988();
|
|
auto ccfg = ptr->component_config();
|
|
ccfg.stored_size = STORED_SIZE;
|
|
ptr->component_config(ccfg);
|
|
return ptr;
|
|
}
|
|
virtual bool is_using_hal() const override
|
|
{
|
|
return GetParam();
|
|
};
|
|
};
|
|
|
|
// INSTANTIATE_TEST_SUITE_P(ParamValues, TestQMP6988,
|
|
// ::testing::Values(false, true));
|
|
// INSTANTIATE_TEST_SUITE_P(ParamValues, TestQMP6988, ::testing::Values(true));
|
|
INSTANTIATE_TEST_SUITE_P(ParamValues, TestQMP6988, ::testing::Values(false));
|
|
|
|
namespace {
|
|
constexpr Oversampling os_table[] = {
|
|
Oversampling::Skipped, Oversampling::X1, Oversampling::X2, Oversampling::X4,
|
|
Oversampling::X8, Oversampling::X16, Oversampling::X32, Oversampling::X64,
|
|
};
|
|
|
|
constexpr OversamplingSetting oss_table[] = {
|
|
OversamplingSetting::HighSpeed, OversamplingSetting::LowPower, OversamplingSetting::Standard,
|
|
OversamplingSetting::HighAccuracy, OversamplingSetting::UltraHightAccuracy,
|
|
};
|
|
|
|
constexpr Oversampling osrss_table[][2] = {
|
|
// Pressure, Temperature
|
|
{Oversampling::X2, Oversampling::X1}, {Oversampling::X4, Oversampling::X1}, {Oversampling::X8, Oversampling::X1},
|
|
{Oversampling::X16, Oversampling::X2}, {Oversampling::X32, Oversampling::X4},
|
|
};
|
|
|
|
constexpr Filter filter_table[] = {
|
|
Filter::Off, Filter::Coeff2, Filter::Coeff4, Filter::Coeff8, Filter::Coeff16, Filter::Coeff32,
|
|
|
|
};
|
|
|
|
constexpr Standby standby_table[] = {
|
|
Standby::Time1ms, Standby::Time5ms, Standby::Time50ms, Standby::Time250ms,
|
|
Standby::Time500ms, Standby::Time1sec, Standby::Time2sec, Standby::Time4sec,
|
|
};
|
|
|
|
constexpr PowerMode pw_table[] = {
|
|
PowerMode::Sleep,
|
|
PowerMode::Forced,
|
|
PowerMode::Normal,
|
|
};
|
|
|
|
constexpr UseCase uc_table[] = {
|
|
UseCase::Weather, UseCase::Drop, UseCase::Elevator, UseCase::Stair, UseCase::Indoor,
|
|
};
|
|
|
|
struct UseCaseSetting {
|
|
OversamplingSetting osrss;
|
|
Filter filter;
|
|
};
|
|
|
|
constexpr UseCaseSetting uc_val_table[] = {
|
|
{OversamplingSetting::HighSpeed, Filter::Off},
|
|
{OversamplingSetting::LowPower, Filter::Off},
|
|
{OversamplingSetting::Standard, Filter::Coeff4},
|
|
{OversamplingSetting::HighAccuracy, Filter::Coeff8},
|
|
{OversamplingSetting::UltraHightAccuracy, Filter::Coeff32},
|
|
};
|
|
|
|
template <class U>
|
|
elapsed_time_t test_periodic(U* unit, const uint32_t times, const uint32_t measure_duration = 0)
|
|
{
|
|
auto tm = unit->interval();
|
|
auto timeout_at = m5::utility::millis() + 8 * 1000;
|
|
// First measured
|
|
do {
|
|
unit->update();
|
|
if (unit->updated()) {
|
|
break;
|
|
}
|
|
std::this_thread::yield();
|
|
} while (!unit->updated() && m5::utility::millis() <= timeout_at);
|
|
// timeout
|
|
if (!unit->updated()) {
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
uint32_t measured{};
|
|
auto start_at = m5::utility::millis();
|
|
timeout_at = start_at + (times * (tm + measure_duration) * 2);
|
|
do {
|
|
unit->update();
|
|
measured += unit->updated() ? 1 : 0;
|
|
if (measured >= times) {
|
|
break;
|
|
}
|
|
std::this_thread::yield();
|
|
// m5::utility::delay(1);
|
|
|
|
} while (measured < times && m5::utility::millis() <= timeout_at);
|
|
|
|
if (measured == times) {
|
|
return m5::utility::millis() - start_at;
|
|
}
|
|
M5_LOGE("measured:%u", measured);
|
|
return -1;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
TEST_P(TestQMP6988, Settings)
|
|
{
|
|
SCOPED_TRACE(ustr);
|
|
|
|
// Oversampling
|
|
if (1) {
|
|
// This process fails during periodic measurements.
|
|
EXPECT_TRUE(unit->inPeriodic());
|
|
for (auto&& po : os_table) {
|
|
for (auto&& to : os_table) {
|
|
auto s = m5::utility::formatString("OSRS:%u/%u", po, to);
|
|
SCOPED_TRACE(s);
|
|
|
|
EXPECT_FALSE(unit->writeOversampling(po, to));
|
|
EXPECT_FALSE(unit->writeOversamplingPressure(po));
|
|
EXPECT_FALSE(unit->writeOversamplingTemperature(to));
|
|
}
|
|
}
|
|
|
|
// Success if not in periodic measurement
|
|
EXPECT_TRUE(unit->stopPeriodicMeasurement());
|
|
EXPECT_FALSE(unit->inPeriodic());
|
|
for (auto&& po : os_table) {
|
|
for (auto&& to : os_table) {
|
|
Oversampling p;
|
|
Oversampling t;
|
|
|
|
auto s = m5::utility::formatString("OSRS:%u/%u", po, to);
|
|
SCOPED_TRACE(s);
|
|
|
|
EXPECT_TRUE(unit->writeOversampling(po, to));
|
|
EXPECT_TRUE(unit->readOversampling(p, t));
|
|
EXPECT_EQ(p, po);
|
|
EXPECT_EQ(t, to);
|
|
|
|
// Write reverse settings and check
|
|
EXPECT_TRUE(unit->writeOversamplingPressure(to));
|
|
EXPECT_TRUE(unit->readOversampling(p, t));
|
|
EXPECT_EQ(p, to);
|
|
EXPECT_EQ(t, to);
|
|
|
|
EXPECT_TRUE(unit->writeOversamplingTemperature(po));
|
|
EXPECT_TRUE(unit->readOversampling(p, t));
|
|
EXPECT_EQ(p, to);
|
|
EXPECT_EQ(t, po);
|
|
}
|
|
}
|
|
}
|
|
|
|
// OversamplingSettings
|
|
if (1) {
|
|
// This process fails during periodic measurements.
|
|
EXPECT_TRUE(unit->startPeriodicMeasurement());
|
|
EXPECT_TRUE(unit->inPeriodic());
|
|
for (auto& oss : oss_table) {
|
|
auto s = m5::utility::formatString("OSS:%u", oss);
|
|
SCOPED_TRACE(s);
|
|
EXPECT_FALSE(unit->writeOversampling(oss));
|
|
}
|
|
|
|
// Success if not in periodic measurement
|
|
EXPECT_TRUE(unit->stopPeriodicMeasurement());
|
|
EXPECT_FALSE(unit->inPeriodic());
|
|
|
|
uint32_t idx{};
|
|
for (auto& oss : oss_table) {
|
|
auto s = m5::utility::formatString("OSS:%u", oss);
|
|
SCOPED_TRACE(s);
|
|
|
|
EXPECT_TRUE(unit->writeOversampling(oss));
|
|
|
|
Oversampling p;
|
|
Oversampling t;
|
|
EXPECT_TRUE(unit->readOversampling(p, t));
|
|
EXPECT_EQ(p, osrss_table[idx][0]);
|
|
EXPECT_EQ(t, osrss_table[idx][1]);
|
|
|
|
++idx;
|
|
}
|
|
}
|
|
|
|
// Filter
|
|
if (1) {
|
|
// This process fails during periodic measurements.
|
|
EXPECT_TRUE(unit->startPeriodicMeasurement());
|
|
EXPECT_TRUE(unit->inPeriodic());
|
|
|
|
for (auto&& e : filter_table) {
|
|
auto s = m5::utility::formatString("F:%u", e);
|
|
SCOPED_TRACE(s);
|
|
|
|
EXPECT_FALSE(unit->writeFilter(e));
|
|
}
|
|
|
|
// Success if not in periodic measurement
|
|
EXPECT_TRUE(unit->stopPeriodicMeasurement());
|
|
EXPECT_FALSE(unit->inPeriodic());
|
|
|
|
for (auto&& e : filter_table) {
|
|
auto s = m5::utility::formatString("F:%u", e);
|
|
SCOPED_TRACE(s);
|
|
EXPECT_TRUE(unit->writeFilter(e));
|
|
|
|
Filter f;
|
|
EXPECT_TRUE(unit->readFilter(f));
|
|
EXPECT_EQ(f, e);
|
|
}
|
|
}
|
|
|
|
// Standby
|
|
if (1) {
|
|
// This process fails during periodic measurements.
|
|
EXPECT_TRUE(unit->startPeriodicMeasurement());
|
|
EXPECT_TRUE(unit->inPeriodic());
|
|
for (auto&& e : standby_table) {
|
|
auto s = m5::utility::formatString("ST:%u", e);
|
|
SCOPED_TRACE(s);
|
|
EXPECT_FALSE(unit->writeStandbyTime(e));
|
|
}
|
|
|
|
// Success if not in periodic measurement
|
|
EXPECT_TRUE(unit->stopPeriodicMeasurement());
|
|
EXPECT_FALSE(unit->inPeriodic());
|
|
for (auto&& e : standby_table) {
|
|
auto s = m5::utility::formatString("ST:%u", e);
|
|
SCOPED_TRACE(s);
|
|
EXPECT_TRUE(unit->writeStandbyTime(e));
|
|
|
|
Standby st;
|
|
EXPECT_TRUE(unit->readStandbyTime(st));
|
|
EXPECT_EQ(st, e);
|
|
}
|
|
}
|
|
|
|
// PowerMode
|
|
if (1) {
|
|
for (auto&& pw : pw_table) {
|
|
auto s = m5::utility::formatString("PM:%u", pw);
|
|
SCOPED_TRACE(s);
|
|
|
|
EXPECT_TRUE(unit->writePowerMode(pw));
|
|
|
|
PowerMode p{};
|
|
EXPECT_TRUE(unit->readPowerMode(p));
|
|
EXPECT_EQ(p, pw);
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_P(TestQMP6988, UseCase)
|
|
{
|
|
SCOPED_TRACE(ustr);
|
|
EXPECT_TRUE(unit->inPeriodic());
|
|
|
|
// This process fails during periodic measurements.
|
|
for (auto&& uc : uc_table) {
|
|
auto s = m5::utility::formatString("UC:%u", uc);
|
|
SCOPED_TRACE(s);
|
|
EXPECT_FALSE(unit->writeUseCaseSetting(uc));
|
|
}
|
|
|
|
// Success if not in periodic measurement
|
|
EXPECT_TRUE(unit->stopPeriodicMeasurement());
|
|
EXPECT_FALSE(unit->inPeriodic());
|
|
for (auto&& uc : uc_table) {
|
|
auto s = m5::utility::formatString("UC:%u", uc);
|
|
SCOPED_TRACE(s);
|
|
EXPECT_TRUE(unit->writeUseCaseSetting(uc));
|
|
|
|
Oversampling p{};
|
|
Oversampling t{};
|
|
Filter f{};
|
|
const auto& val = uc_val_table[m5::stl::to_underlying(uc)];
|
|
const auto& osrrs = osrss_table[m5::stl::to_underlying(val.osrss)];
|
|
|
|
EXPECT_TRUE(unit->readOversampling(p, t));
|
|
EXPECT_TRUE(unit->readFilter(f));
|
|
|
|
EXPECT_EQ(p, osrrs[0]);
|
|
EXPECT_EQ(t, osrrs[1]);
|
|
EXPECT_EQ(f, val.filter);
|
|
}
|
|
}
|
|
|
|
TEST_P(TestQMP6988, Reset)
|
|
{
|
|
SCOPED_TRACE(ustr);
|
|
|
|
EXPECT_TRUE(unit->inPeriodic());
|
|
|
|
Oversampling p{}, t{};
|
|
Filter f{};
|
|
Standby s{};
|
|
PowerMode pm{};
|
|
EXPECT_TRUE(unit->readOversampling(p, t));
|
|
EXPECT_TRUE(unit->readFilter(f));
|
|
EXPECT_TRUE(unit->readStandbyTime(s));
|
|
EXPECT_TRUE(unit->readPowerMode(pm));
|
|
|
|
EXPECT_NE(p, Oversampling::Skipped);
|
|
EXPECT_NE(t, Oversampling::Skipped);
|
|
EXPECT_NE(f, Filter::Off);
|
|
EXPECT_NE(s, Standby::Time1ms);
|
|
EXPECT_EQ(pm, PowerMode::Normal);
|
|
|
|
EXPECT_TRUE(unit->softReset());
|
|
|
|
EXPECT_TRUE(unit->readOversampling(p, t));
|
|
EXPECT_TRUE(unit->readFilter(f));
|
|
EXPECT_TRUE(unit->readStandbyTime(s));
|
|
EXPECT_TRUE(unit->readPowerMode(pm));
|
|
|
|
EXPECT_EQ(p, Oversampling::Skipped);
|
|
EXPECT_EQ(t, Oversampling::Skipped);
|
|
EXPECT_EQ(f, Filter::Off);
|
|
EXPECT_EQ(s, Standby::Time1ms);
|
|
EXPECT_EQ(pm, PowerMode::Sleep);
|
|
}
|
|
|
|
TEST_P(TestQMP6988, SingleShot)
|
|
{
|
|
SCOPED_TRACE(ustr);
|
|
|
|
// This process fails during periodic measurements.
|
|
EXPECT_TRUE(unit->inPeriodic());
|
|
qmp6988::Data discard{};
|
|
EXPECT_FALSE(unit->measureSingleshot(discard));
|
|
|
|
// Success if not in periodic measurement
|
|
EXPECT_TRUE(unit->stopPeriodicMeasurement());
|
|
EXPECT_FALSE(unit->inPeriodic());
|
|
|
|
// Standby time for periodic measurement, does not affect single shots
|
|
EXPECT_TRUE(unit->writeStandbyTime(Standby::Time4sec));
|
|
|
|
for (auto&& po : os_table) {
|
|
for (auto&& to : os_table) {
|
|
for (auto&& coeff : filter_table) {
|
|
auto s = m5::utility::formatString("Singleshot OS:%u/%u F:%u", po, to, coeff);
|
|
SCOPED_TRACE(s);
|
|
|
|
// Specify settings and measure
|
|
qmp6988::Data d{};
|
|
bool can_not_measure = to == Oversampling::Skipped;
|
|
bool only_temperature = to != Oversampling::Skipped && po == Oversampling::Skipped;
|
|
|
|
// M5_LOGI("%s:<%u><%u>", s.c_str(), can_not_measure, only_temperature);
|
|
|
|
if (can_not_measure) {
|
|
EXPECT_FALSE(unit->measureSingleshot(d, po, to, coeff));
|
|
|
|
} else if (only_temperature) {
|
|
EXPECT_TRUE(unit->measureSingleshot(d, po, to, coeff));
|
|
|
|
// M5_LOGI("%f/%f/%f", d.celsius(), d.fahrenheit(), d.pressure());
|
|
|
|
EXPECT_TRUE(std::isfinite(d.celsius()));
|
|
EXPECT_TRUE(std::isfinite(d.fahrenheit()));
|
|
EXPECT_FALSE(std::isfinite(d.pressure()));
|
|
} else {
|
|
EXPECT_TRUE(unit->measureSingleshot(d, po, to, coeff));
|
|
|
|
// M5_LOGI("%f/%f", d.celsius(), d.pressure());
|
|
|
|
EXPECT_TRUE(std::isfinite(d.celsius()));
|
|
EXPECT_TRUE(std::isfinite(d.fahrenheit()));
|
|
EXPECT_TRUE(std::isfinite(d.pressure()));
|
|
}
|
|
|
|
if (!can_not_measure) {
|
|
Oversampling t;
|
|
Oversampling p;
|
|
Filter f;
|
|
EXPECT_TRUE(unit->readOversampling(p, t));
|
|
EXPECT_TRUE(unit->readFilter(f));
|
|
EXPECT_EQ(p, po);
|
|
EXPECT_EQ(t, to);
|
|
EXPECT_EQ(f, coeff);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_P(TestQMP6988, Periodic)
|
|
{
|
|
SCOPED_TRACE(ustr);
|
|
|
|
EXPECT_TRUE(unit->stopPeriodicMeasurement());
|
|
EXPECT_FALSE(unit->inPeriodic());
|
|
|
|
for (auto&& uc : uc_table) {
|
|
for (auto&& st : standby_table) {
|
|
auto s = m5::utility::formatString("UC:%u ST:%u", uc, st);
|
|
SCOPED_TRACE(s);
|
|
|
|
// M5_LOGW("%s", s.c_str());
|
|
|
|
const auto& val = uc_val_table[m5::stl::to_underlying(uc)];
|
|
const auto& osrrs = osrss_table[m5::stl::to_underlying(val.osrss)];
|
|
|
|
EXPECT_TRUE(unit->writeUseCaseSetting(uc));
|
|
EXPECT_TRUE(unit->writeStandbyTime(st));
|
|
EXPECT_TRUE(unit->startPeriodicMeasurement());
|
|
EXPECT_TRUE(unit->inPeriodic());
|
|
auto tm = unit->interval();
|
|
auto elapsed = test_periodic(unit.get(), STORED_SIZE, (int)st == 0 ? ((uint32_t)uc + 1) * 2 : 0);
|
|
|
|
EXPECT_TRUE(unit->stopPeriodicMeasurement());
|
|
EXPECT_FALSE(unit->inPeriodic());
|
|
|
|
// M5_LOGW("E:(%u) %ld", tm == 1 ? (uint32_t)uc * 2 : 0, elapsed);
|
|
|
|
EXPECT_NE(elapsed, 0);
|
|
EXPECT_NE(elapsed, -1);
|
|
EXPECT_GE(elapsed, STORED_SIZE * tm - 1);
|
|
|
|
Oversampling t;
|
|
Oversampling p;
|
|
Filter f;
|
|
EXPECT_TRUE(unit->readOversampling(p, t));
|
|
EXPECT_TRUE(unit->readFilter(f));
|
|
EXPECT_EQ(p, osrrs[0]);
|
|
EXPECT_EQ(t, osrrs[1]);
|
|
EXPECT_EQ(f, val.filter);
|
|
|
|
//
|
|
EXPECT_EQ(unit->available(), STORED_SIZE);
|
|
EXPECT_FALSE(unit->empty());
|
|
EXPECT_TRUE(unit->full());
|
|
|
|
uint32_t cnt{STORED_SIZE / 2};
|
|
while (cnt-- && unit->available()) {
|
|
// M5_LOGI("%f/%f/%f", unit->celsius(), unit->fahrenheit(), unit->pressure());
|
|
|
|
EXPECT_TRUE(std::isfinite(unit->temperature()));
|
|
EXPECT_TRUE(std::isfinite(unit->fahrenheit()));
|
|
EXPECT_TRUE(std::isfinite(unit->pressure()));
|
|
EXPECT_FLOAT_EQ(unit->temperature(), unit->oldest().temperature());
|
|
EXPECT_FLOAT_EQ(unit->pressure(), unit->oldest().pressure());
|
|
EXPECT_FALSE(unit->empty());
|
|
unit->discard();
|
|
}
|
|
EXPECT_EQ(unit->available(), STORED_SIZE / 2);
|
|
EXPECT_FALSE(unit->empty());
|
|
EXPECT_FALSE(unit->full());
|
|
|
|
unit->flush();
|
|
EXPECT_EQ(unit->available(), 0);
|
|
EXPECT_TRUE(unit->empty());
|
|
EXPECT_FALSE(unit->full());
|
|
|
|
EXPECT_FALSE(std::isfinite(unit->temperature()));
|
|
EXPECT_FALSE(std::isfinite(unit->pressure()));
|
|
}
|
|
}
|
|
}
|