diff --git a/platformio.ini b/platformio.ini
index 46cb729..b366966 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -25,7 +25,7 @@ test_ignore= native/*
 
 [Core]
 extends = m5base
-board = m5stack-core-esp32-16M
+board = m5stack-grey
 ;m5stack-grey
 ;m5stack-core-esp32-16M ;;6.8.0 or later
 ;m5stack-core-esp32
diff --git a/src/unit/unit_BME688.cpp b/src/unit/unit_BME688.cpp
index d493fc1..3b80f8a 100644
--- a/src/unit/unit_BME688.cpp
+++ b/src/unit/unit_BME688.cpp
@@ -200,19 +200,19 @@ void UnitBME688::update_bsec2(const bool force) {
 
     switch (_bsec2_settings.op_mode) {
         case BME68X_FORCED_MODE:
-            if (!set_forced_mode()) {
+            if (!write_mode_forced()) {
                 return;
             }
             _bsec2_mode = Mode::Forced;
             break;
         case BME68X_SLEEP_MODE:
-            if (_bsec2_mode != _bsec2_settings.op_mode && setMode(Mode::Sleep)) {
+            if (_bsec2_mode != _bsec2_settings.op_mode && writeMode(Mode::Sleep)) {
                 _bsec2_mode = Mode::Sleep;
             }
             break;
         case BME68X_PARALLEL_MODE:
             if (_bsec2_mode != _bsec2_settings.op_mode) {
-                if (!set_parallel_mode()) {
+                if (!write_mode_parallel()) {
                     return;
                 }
                 _bsec2_mode = Mode::Parallel;
@@ -249,14 +249,18 @@ void UnitBME688::update_bme688(const bool force) {
     }
 
     elapsed_time_t at{m5::utility::millis()};
+    if (_waiting) {
+        _waiting = (at < _can_measure_time);
+        return;
+    }
+
     if (force || !_latest || at >= _latest + _interval) {
         _updated = read_measurement();
         if (_updated) {
             switch (_mode) {
-                    // Forced goes to sleep after measurement, so set it up
-                    // again
+                    // Forced goes to sleep after measurement, so set it up again
                 case Mode::Forced:
-                    if (!setMode(Mode::Forced)) {
+                    if (!writeMode(Mode::Forced)) {
                         M5_LIB_LOGE("Failed to sete mode again");
                         _updated  = false;
                         _mode     = Mode::Sleep;
@@ -354,7 +358,7 @@ bool UnitBME688::readCalibration(bme688::Calibration& c) {
     return true;
 }
 
-bool UnitBME688::setCalibration(const bme688::Calibration& c) {
+bool UnitBME688::writeCalibration(const bme688::Calibration& c) {
     std::array<uint8_t, 23> array0{};  // 0x8A
     std::array<uint8_t, 14> array1{};  // 0xE1
     std::array<uint8_t, 3> array2{};   // 0x00
@@ -408,7 +412,7 @@ bool UnitBME688::readTPHSetting(bme688::bme68xConf& s) {
     return bme68x_get_conf(&s, &_dev) == BME68X_OK;
 }
 
-bool UnitBME688::setTPHSetting(const bme688::bme68xConf& s) {
+bool UnitBME688::writeTPHSetting(const bme688::bme68xConf& s) {
     // bme68x_set_conf argument does not const...
     if (bme68x_set_conf(const_cast<struct bme68x_conf*>(&s), &_dev) == BME68X_OK) {
         _tphConf = s;
@@ -457,8 +461,8 @@ bool UnitBME688::readIIRFilter(bme688::Filter& f) {
     return false;
 }
 
-bool UnitBME688::setOversampling(const bme688::Oversampling t, const bme688::Oversampling p,
-                                 const bme688::Oversampling h) {
+bool UnitBME688::writeOversampling(const bme688::Oversampling t, const bme688::Oversampling p,
+                                   const bme688::Oversampling h) {
     uint8_t tp{}, hm{};
     if (readRegister8(CTRL_MEASUREMENT, tp, 0) && readRegister8(CTRL_HUMIDITY, hm, 0)) {
         tp = (tp & ~((0x07 << 5) | (0x07 << 2))) | (m5::stl::to_underlying(t) << 5) | (m5::stl::to_underlying(p) << 2);
@@ -473,7 +477,7 @@ bool UnitBME688::setOversampling(const bme688::Oversampling t, const bme688::Ove
     return false;
 }
 
-bool UnitBME688::setOversamplingTemperature(const bme688::Oversampling os) {
+bool UnitBME688::writeOversamplingTemperature(const bme688::Oversampling os) {
     uint8_t v{};
     if (readRegister8(CTRL_MEASUREMENT, v, 0)) {
         v = (v & ~((0x07 << 5) | 0x03)) | (m5::stl::to_underlying(os) << 5);
@@ -485,7 +489,7 @@ bool UnitBME688::setOversamplingTemperature(const bme688::Oversampling os) {
     return false;
 }
 
-bool UnitBME688::setOversamplingPressure(const bme688::Oversampling os) {
+bool UnitBME688::writeOversamplingPressure(const bme688::Oversampling os) {
     uint8_t v{};
     if (readRegister8(CTRL_MEASUREMENT, v, 0)) {
         v = (v & ~((0x07 << 2) | 0x03)) | (m5::stl::to_underlying(os) << 2);
@@ -497,7 +501,7 @@ bool UnitBME688::setOversamplingPressure(const bme688::Oversampling os) {
     return false;
 }
 
-bool UnitBME688::setOversamplingHumidity(const bme688::Oversampling os) {
+bool UnitBME688::writeOversamplingHumidity(const bme688::Oversampling os) {
     uint8_t v{};
     if (readRegister8(CTRL_HUMIDITY, v, 0)) {
         v = (v & ~0x07) | m5::stl::to_underlying(os);
@@ -509,7 +513,7 @@ bool UnitBME688::setOversamplingHumidity(const bme688::Oversampling os) {
     return false;
 }
 
-bool UnitBME688::setIIRFilter(const bme688::Filter f) {
+bool UnitBME688::writeIIRFilter(const bme688::Filter f) {
     uint8_t v{};
     if (readRegister8(CONFIG, v, 0)) {
         v = (v & ~(0x07 << 2)) | (m5::stl::to_underlying(f) << 2);
@@ -521,7 +525,7 @@ bool UnitBME688::setIIRFilter(const bme688::Filter f) {
     return false;
 }
 
-bool UnitBME688::setHeaterSetting(const Mode mode, const bme688::bme68xHeatrConf& hs) {
+bool UnitBME688::writeHeaterSetting(const Mode mode, const bme688::bme68xHeatrConf& hs) {
     if (bme68x_set_heatr_conf(m5::stl::to_underlying(mode), &hs, &_dev) == BME68X_OK) {
         _heaterConf = hs;
         return true;
@@ -529,7 +533,7 @@ bool UnitBME688::setHeaterSetting(const Mode mode, const bme688::bme68xHeatrConf
     return false;
 }
 
-bool UnitBME688::setMode(const Mode m) {
+bool UnitBME688::writeMode(const Mode m) {
     if (bme68x_set_op_mode(m5::stl::to_underlying(m), &_dev) == BME68X_OK) {
         _mode = m;
         return true;
@@ -554,7 +558,7 @@ bool UnitBME688::measureSingleShot(bme688::bme68xData& data) {
         return false;
     }
 
-    if (setMode(Mode::Forced)) {
+    if (writeMode(Mode::Forced)) {
         auto interval_us = calculateMeasurementInterval(_mode, _tphConf) + (_heaterConf.heatr_dur * 1000);
         auto interval_ms = interval_us / 1000 + ((interval_us % 1000) != 0);
         m5::utility::delay(interval_ms);
@@ -582,7 +586,7 @@ bool UnitBME688::startPeriodicMeasurement(const Mode m) {
         return false;
     }
 
-    if (setMode(m)) {
+    if (writeMode(m)) {
         auto interval_us = calculateMeasurementInterval(_mode, _tphConf);
         switch (m) {
             case Mode::Forced:
@@ -597,11 +601,15 @@ bool UnitBME688::startPeriodicMeasurement(const Mode m) {
             default:
                 return false;
         }
+        // TODO: Parallel is wrong!?
+        //
+        //        M5_LIB_LOGW(">>>> INTERVAL:%u", interval_us);
         _interval = interval_us / 1000 + ((interval_us % 1000) != 0);
-        // Always wait for an interval to obtain the correct value for the first
-        // measurement
-        _latest   = m5::utility::millis();
-        _periodic = true;
+        // Always wait for an interval to obtain the correct value for the first measurement
+        _can_measure_time = m5::utility::millis() + _interval;
+        _waiting          = true;
+        _latest           = 0;
+        _periodic         = true;
     }
     return _periodic;
 }
@@ -612,7 +620,7 @@ bool UnitBME688::stopPeriodicMeasurement() {
         return false;
     }
 
-    if (setMode(Mode::Sleep)) {
+    if (writeMode(Mode::Sleep)) {
         _periodic = false;
     }
     return !_periodic;
@@ -726,18 +734,18 @@ bool UnitBME688::bsec2UnsubscribeAll() {
 }
 
 //
-bool UnitBME688::set_forced_mode() {
+bool UnitBME688::write_mode_forced() {
     bme688::bme68xHeatrConf hs{};
     hs.enable     = true;
     hs.heatr_temp = _bsec2_settings.heater_temperature;
     hs.heatr_dur  = _bsec2_settings.heater_duration;
-    return setOversampling((Oversampling)_bsec2_settings.temperature_oversampling,
-                           (Oversampling)_bsec2_settings.pressure_oversampling,
-                           (Oversampling)_bsec2_settings.humidity_oversampling) &&
-           setHeaterSetting(Mode::Forced, hs) && setMode(Mode::Forced);
+    return writeOversampling((Oversampling)_bsec2_settings.temperature_oversampling,
+                             (Oversampling)_bsec2_settings.pressure_oversampling,
+                             (Oversampling)_bsec2_settings.humidity_oversampling) &&
+           writeHeaterSetting(Mode::Forced, hs) && writeMode(Mode::Forced);
 }
 
-bool UnitBME688::set_parallel_mode() {
+bool UnitBME688::write_mode_parallel() {
     uint16_t shared{};
     bme688::bme68xHeatrConf hs{};
 
@@ -751,10 +759,10 @@ bool UnitBME688::set_parallel_mode() {
     memcpy(hs.heatr_dur_prof, _bsec2_settings.heater_duration_profile, sizeof(uint16_t) * hs.profile_len);
     hs.shared_heatr_dur = shared;
 
-    return setOversampling((Oversampling)_bsec2_settings.temperature_oversampling,
-                           (Oversampling)_bsec2_settings.pressure_oversampling,
-                           (Oversampling)_bsec2_settings.humidity_oversampling) &&
-           setHeaterSetting(Mode::Parallel, hs) && setMode(Mode::Parallel);
+    return writeOversampling((Oversampling)_bsec2_settings.temperature_oversampling,
+                             (Oversampling)_bsec2_settings.pressure_oversampling,
+                             (Oversampling)_bsec2_settings.humidity_oversampling) &&
+           writeHeaterSetting(Mode::Parallel, hs) && writeMode(Mode::Parallel);
 }
 
 bool UnitBME688::fetch_data() {
diff --git a/src/unit/unit_BME688.hpp b/src/unit/unit_BME688.hpp
index a22d11b..02e2bff 100644
--- a/src/unit/unit_BME688.hpp
+++ b/src/unit/unit_BME688.hpp
@@ -367,11 +367,11 @@ class UnitBME688 : public Component {
      */
     bool readCalibration(bme688::Calibration& c);
     /*!
-      @brief set calibration
+      @brief write calibration
       @param c Calibration parameter
       @return True if successful
      */
-    bool setCalibration(const bme688::Calibration& c);
+    bool writeCalibration(const bme688::Calibration& c);
     /*!
       @brief Calculation of measurement intervals without heater
       @return interval time (Unit: us)
@@ -394,11 +394,11 @@ class UnitBME688 : public Component {
     */
     bool selfTest();
     /*!
-      @brief Set operation mode
+      @brief Write operation mode
       @param m Mode
       @return True if successful
      */
-    bool setMode(const bme688::Mode m);
+    bool writeMode(const bme688::Mode m);
     /*!
       @brief Read operation mode
       @param[out] m Mode
@@ -439,51 +439,51 @@ class UnitBME688 : public Component {
      */
     bool readOversamplingHumidity(bme688::Oversampling& os);
     /*!
-      @brief Set TPH setting
+      @brief Write TPH setting
       @param s Setting
       @return True if successful
     */
-    bool setTPHSetting(const bme688::bme68xConf& s);
+    bool writeTPHSetting(const bme688::bme68xConf& s);
     /*!
-      @brief Set oversamplings
+      @brief Wite oversamplings
       @param t oversampling for temperature
       @param p oversampling for pressure
       @param h oversampling for humidity
     */
-    bool setOversampling(const bme688::Oversampling t, const bme688::Oversampling p, const bme688::Oversampling h);
+    bool writeOversampling(const bme688::Oversampling t, const bme688::Oversampling p, const bme688::Oversampling h);
     /*!
-      @brief Set temperature oversampling
+      @brief Write temperature oversampling
       @param os enum value
       @return True if successful
      */
-    bool setOversamplingTemperature(const bme688::Oversampling os);
+    bool writeOversamplingTemperature(const bme688::Oversampling os);
     /*!
-      @brief Set pressure oversampling
+      @brief Write pressure oversampling
       @param os enum value
       @return True if successful
      */
-    bool setOversamplingPressure(const bme688::Oversampling os);
+    bool writeOversamplingPressure(const bme688::Oversampling os);
     /*!
-      @brief Set humidity oversampling
+      @brief Write humidity oversampling
       @param os enum value
       @return True if successful
      */
-    bool setOversamplingHumidity(const bme688::Oversampling os);
+    bool writeOversamplingHumidity(const bme688::Oversampling os);
     /*!
-      @brief Set IIRFilter
+      @brief Write IIRFilter
       @param[out] f enum value
       @return True if successful
     */
-    bool setIIRFilter(const bme688::Filter f);
+    bool writeIIRFilter(const bme688::Filter f);
     ///@}
 
     /*!
-      @brief Set heater setting
+      @brief Write heater setting
       @param mode Expected operation mode of the sensor
       @param hs Setting
       @return True if successful
      */
-    bool setHeaterSetting(const bme688::Mode mode, const bme688::bme68xHeatrConf& hs);
+    bool writeHeaterSetting(const bme688::Mode mode, const bme688::bme68xHeatrConf& hs);
 
     ///@name Using bme688 directly
     ///@{
@@ -633,8 +633,8 @@ class UnitBME688 : public Component {
     static int8_t read_function(uint8_t reg_addr, uint8_t* reg_data, uint32_t length, void* intf_ptr);
     static int8_t write_function(uint8_t reg_addr, const uint8_t* reg_data, uint32_t length, void* intf_ptr);
 
-    bool set_forced_mode();
-    bool set_parallel_mode();
+    bool write_mode_forced();
+    bool write_mode_parallel();
     bool fetch_data();
     bool process_data(const int64_t ns, const bme688::bme68xData& data);
 
@@ -665,6 +665,9 @@ class UnitBME688 : public Component {
     float _temperatureOffset{};
 #endif
 
+    bool _waiting{};
+    types::elapsed_time_t _can_measure_time{};
+    
     config_t _cfg{};
 };
 
diff --git a/src/unit/unit_QMP6988.cpp b/src/unit/unit_QMP6988.cpp
index 9e813b0..2868bf9 100644
--- a/src/unit/unit_QMP6988.cpp
+++ b/src/unit/unit_QMP6988.cpp
@@ -186,12 +186,12 @@ bool UnitQMP6988::begin() {
         return false;
     }
 
-    if (!setOversamplings(_cfg.oversampling_temperature, _cfg.oversampling_pressure) || !setFilterCoeff(_cfg.filter) ||
-        !setStandbyTime(_cfg.standby_time)) {
+    if (!writeOversamplings(_cfg.oversampling_temperature, _cfg.oversampling_pressure) ||
+        !writeFilterCoeff(_cfg.filter) || !writeStandbyTime(_cfg.standby_time)) {
         M5_LIB_LOGE("Failed to settings");
         return false;
     }
-    return _cfg.start_periodic ? startPeriodicMeasurement() : setPowerMode(qmp6988::PowerMode::Sleep);
+    return _cfg.start_periodic ? startPeriodicMeasurement() : writePowerMode(qmp6988::PowerMode::Sleep);
 }
 
 void UnitQMP6988::update(const bool force) {
@@ -213,7 +213,7 @@ bool UnitQMP6988::start_periodic_measurement() {
     if (inPeriodic()) {
         return false;
     }
-    return setPowerMode(qmp6988::PowerMode::Normal);
+    return writePowerMode(qmp6988::PowerMode::Normal);
 }
 
 bool UnitQMP6988::start_periodic_measurement(const qmp6988::StandbyTime st, const qmp6988::Oversampling ost,
@@ -226,12 +226,12 @@ bool UnitQMP6988::start_periodic_measurement(const qmp6988::StandbyTime st, cons
     cm.oversamplingTemperature(ost);
     cm.oversamplingPressure(osp);
     cm.mode(PowerMode::Normal);
-    return setPowerMode(PowerMode::Sleep) && setFilterCoeff(f) && setStandbyTime(st) &&
-           set_measurement_condition(cm.value);
+    return writePowerMode(PowerMode::Sleep) && writeFilterCoeff(f) && writeStandbyTime(st) &&
+           write_measurement_condition(cm.value);
 }
 
 bool UnitQMP6988::stop_periodic_measurement() {
-    return setPowerMode(qmp6988::PowerMode::Sleep);
+    return writePowerMode(qmp6988::PowerMode::Sleep);
 }
 
 bool UnitQMP6988::measureSingleshot(qmp6988::Data& d) {
@@ -240,7 +240,7 @@ bool UnitQMP6988::measureSingleshot(qmp6988::Data& d) {
         return false;
     }
 
-    return setPowerMode(qmp6988::PowerMode::Force) && wait_measurement() && read_measurement(d);
+    return writePowerMode(qmp6988::PowerMode::Force) && wait_measurement() && read_measurement(d);
 }
 
 bool UnitQMP6988::measureSingleshot(qmp6988::Data& d, const qmp6988::Oversampling ost, const qmp6988::Oversampling osp,
@@ -254,7 +254,7 @@ bool UnitQMP6988::measureSingleshot(qmp6988::Data& d, const qmp6988::Oversamplin
     cm.oversamplingTemperature(ost);
     cm.oversamplingPressure(osp);
     cm.mode(PowerMode::Force);
-    return setPowerMode(PowerMode::Sleep) && setFilterCoeff(f) && set_measurement_condition(cm.value) &&
+    return writePowerMode(PowerMode::Sleep) && writeFilterCoeff(f) && write_measurement_condition(cm.value) &&
            wait_measurement() && read_measurement(d);
 }
 
@@ -268,7 +268,7 @@ bool UnitQMP6988::readOversamplings(qmp6988::Oversampling& ost, qmp6988::Oversam
     return false;
 }
 
-bool UnitQMP6988::setOversamplings(const qmp6988::Oversampling ost, const qmp6988::Oversampling osp) {
+bool UnitQMP6988::writeOversamplings(const qmp6988::Oversampling ost, const qmp6988::Oversampling osp) {
     if (inPeriodic()) {
         M5_LIB_LOGD("Periodic measurements are running");
         return false;
@@ -278,12 +278,12 @@ bool UnitQMP6988::setOversamplings(const qmp6988::Oversampling ost, const qmp698
     if (read_measurement_condition(cm.value)) {
         cm.oversamplingTemperature(ost);
         cm.oversamplingPressure(osp);
-        return set_measurement_condition(cm.value);
+        return write_measurement_condition(cm.value);
     }
     return false;
 }
 
-bool UnitQMP6988::setOversamplingTemperature(const qmp6988::Oversampling os) {
+bool UnitQMP6988::writeOversamplingTemperature(const qmp6988::Oversampling os) {
     if (inPeriodic()) {
         M5_LIB_LOGD("Periodic measurements are running");
         return false;
@@ -292,12 +292,12 @@ bool UnitQMP6988::setOversamplingTemperature(const qmp6988::Oversampling os) {
     qmp6988::CtrlMeasurement cm{};
     if (read_measurement_condition(cm.value)) {
         cm.oversamplingTemperature(os);
-        return set_measurement_condition(cm.value);
+        return write_measurement_condition(cm.value);
     }
     return false;
 }
 
-bool UnitQMP6988::setOversamplingPressure(const qmp6988::Oversampling os) {
+bool UnitQMP6988::writeOversamplingPressure(const qmp6988::Oversampling os) {
     if (inPeriodic()) {
         M5_LIB_LOGD("Periodic measurements are running");
         return false;
@@ -306,7 +306,7 @@ bool UnitQMP6988::setOversamplingPressure(const qmp6988::Oversampling os) {
     qmp6988::CtrlMeasurement cm{};
     if (read_measurement_condition(cm.value)) {
         cm.oversamplingPressure(os);
-        return set_measurement_condition(cm.value);
+        return write_measurement_condition(cm.value);
     }
     return false;
 }
@@ -320,11 +320,11 @@ bool UnitQMP6988::readPowerMode(qmp6988::PowerMode& m) {
     return false;
 }
 
-bool UnitQMP6988::setPowerMode(const qmp6988::PowerMode m) {
+bool UnitQMP6988::writePowerMode(const qmp6988::PowerMode m) {
     qmp6988::CtrlMeasurement cm{};
     if (read_measurement_condition(cm.value)) {
         cm.mode(m);
-        return set_measurement_condition(cm.value);
+        return write_measurement_condition(cm.value);
     }
     return false;
 }
@@ -350,7 +350,7 @@ bool UnitQMP6988::readFilterCoeff(qmp6988::Filter& f) {
     return false;
 }
 
-bool UnitQMP6988::setFilterCoeff(const qmp6988::Filter& f) {
+bool UnitQMP6988::writeFilterCoeff(const qmp6988::Filter& f) {
     if (inPeriodic()) {
         M5_LIB_LOGD("Periodic measurements are running");
         return false;
@@ -372,7 +372,7 @@ bool UnitQMP6988::readStandbyTime(qmp6988::StandbyTime& st) {
     return false;
 }
 
-bool UnitQMP6988::setStandbyTime(const qmp6988::StandbyTime st) {
+bool UnitQMP6988::writeStandbyTime(const qmp6988::StandbyTime st) {
     if (inPeriodic()) {
         M5_LIB_LOGD("Periodic measurements are running");
         return false;
@@ -384,7 +384,7 @@ bool UnitQMP6988::setStandbyTime(const qmp6988::StandbyTime st) {
             return true;
         }
         is.standby(st);
-        if (set_io_setup(is.value)) {
+        if (write_io_setup(is.value)) {
             _standby = st;
             return true;
         }
@@ -411,7 +411,7 @@ bool UnitQMP6988::read_measurement_condition(uint8_t& cond) {
     return readRegister8(CONTROL_MEASUREMENT, cond, 0);
 }
 
-bool UnitQMP6988::set_measurement_condition(const uint8_t cond) {
+bool UnitQMP6988::write_measurement_condition(const uint8_t cond) {
     if (writeRegister8(CONTROL_MEASUREMENT, cond)) {
         auto prev = _mode;
         qmp6988::CtrlMeasurement cm;
@@ -435,7 +435,7 @@ bool UnitQMP6988::read_io_setup(uint8_t& s) {
     return readRegister8(IO_SETUP, s, 0);
 }
 
-bool UnitQMP6988::set_io_setup(const uint8_t s) {
+bool UnitQMP6988::write_io_setup(const uint8_t s) {
     return writeRegister8(IO_SETUP, s);
 }
 
diff --git a/src/unit/unit_QMP6988.hpp b/src/unit/unit_QMP6988.hpp
index dbb1fee..7e48f2d 100644
--- a/src/unit/unit_QMP6988.hpp
+++ b/src/unit/unit_QMP6988.hpp
@@ -270,29 +270,29 @@ class UnitQMP6988 : public Component, public PeriodicMeasurementAdapter<UnitQMP6
     ///@name Typical use case setup
     ///@{
     /*! @brief For weather monitoring */
-    inline bool setWeathermonitoring() {
-        return setOversamplings(qmp6988::Oversampling::X2, qmp6988::Oversampling::X1) &&
-               setFilterCoeff(qmp6988::Filter::Off);
+    inline bool writeWeathermonitoringSetting() {
+        return writeOversamplings(qmp6988::Oversampling::X2, qmp6988::Oversampling::X1) &&
+               writeFilterCoeff(qmp6988::Filter::Off);
     }
     //! @brief For drop detection
-    bool setDropDetection() {
-        return setOversamplings(qmp6988::Oversampling::X4, qmp6988::Oversampling::X1) &&
-               setFilterCoeff(qmp6988::Filter::Off);
+    bool writeDropDetectionSetting() {
+        return writeOversamplings(qmp6988::Oversampling::X4, qmp6988::Oversampling::X1) &&
+               writeFilterCoeff(qmp6988::Filter::Off);
     }
     //! @brief For elevator detection
-    bool setElevatorDetection() {
-        return setOversamplings(qmp6988::Oversampling::X8, qmp6988::Oversampling::X1) &&
-               setFilterCoeff(qmp6988::Filter::Coeff4);
+    bool writeElevatorDetectionSetting() {
+        return writeOversamplings(qmp6988::Oversampling::X8, qmp6988::Oversampling::X1) &&
+               writeFilterCoeff(qmp6988::Filter::Coeff4);
     }
     //! @brief For stair detection
-    bool setStairDetection() {
-        return setOversamplings(qmp6988::Oversampling::X16, qmp6988::Oversampling::X2) &&
-               setFilterCoeff(qmp6988::Filter::Coeff8);
+    bool writeStairDetectionSetting() {
+        return writeOversamplings(qmp6988::Oversampling::X16, qmp6988::Oversampling::X2) &&
+               writeFilterCoeff(qmp6988::Filter::Coeff8);
     }
     //! @brief For indoor navigation
-    bool setIndoorNavigation() {
-        return setOversamplings(qmp6988::Oversampling::X32, qmp6988::Oversampling::X4) &&
-               setFilterCoeff(qmp6988::Filter::Coeff32);
+    bool writeIndoorNavigationSetting() {
+        return writeOversamplings(qmp6988::Oversampling::X32, qmp6988::Oversampling::X4) &&
+               writeFilterCoeff(qmp6988::Filter::Coeff32);
     }
     ///@}
 
@@ -312,20 +312,20 @@ class UnitQMP6988 : public Component, public PeriodicMeasurementAdapter<UnitQMP6
      */
     bool readPowerMode(qmp6988::PowerMode& mode);
     /*!
-      @brief Set the measurement conditions
+      @brief Write the measurement conditions
       @param ost Oversampling for temperature
       @param osp Oversampling for pressure
       @return True if successful
       @warning If Oversampling::Skip is specified, no measurement is taken
       @warning During periodic detection runs, an error is returned
     */
-    bool setOversamplings(const qmp6988::Oversampling ost, const qmp6988::Oversampling osp);
-    //! @brief Set oversampling for temperature
-    bool setOversamplingTemperature(const qmp6988::Oversampling os);
-    //! @brief Set oversampling for pressure
-    bool setOversamplingPressure(const qmp6988::Oversampling os);
+    bool writeOversamplings(const qmp6988::Oversampling ost, const qmp6988::Oversampling osp);
+    //! @brief Write oversampling for temperature
+    bool writeOversamplingTemperature(const qmp6988::Oversampling os);
+    //! @brief Write oversampling for pressure
+    bool writeOversamplingPressure(const qmp6988::Oversampling os);
     /*!
-      @brief Set power mode
+      @brief Write power mode
       @param mode PowerMode
       @return True if successful
       @note Power mode state changes affect internal operation
@@ -333,7 +333,7 @@ class UnitQMP6988 : public Component, public PeriodicMeasurementAdapter<UnitQMP6
       @warning set PowerMode::Sleep/Force to stop periodic measurement
       @warning set PowerMode::Normal to startp periodic measurement
      */
-    bool setPowerMode(const qmp6988::PowerMode mode);
+    bool writePowerMode(const qmp6988::PowerMode mode);
     ///@}
 
     ///@name IIR filter co-efficient setting
@@ -345,12 +345,12 @@ class UnitQMP6988 : public Component, public PeriodicMeasurementAdapter<UnitQMP6
     */
     bool readFilterCoeff(qmp6988::Filter& f);
     /*!
-      @brief Sets the IIR filter co-efficient
+      @brief Write the IIR filter co-efficient
       @param f filter
       @return True if successful
       @warning During periodic detection runs, an error is returned
     */
-    bool setFilterCoeff(const qmp6988::Filter& f);
+    bool writeFilterCoeff(const qmp6988::Filter& f);
     ///@}
 
     ///@name Interval for periodic measurement
@@ -362,14 +362,14 @@ class UnitQMP6988 : public Component, public PeriodicMeasurementAdapter<UnitQMP6
      */
     bool readStandbyTime(qmp6988::StandbyTime& st);
     /*!
-      @brief Sets the standby time
+      @brief Write the standby time
       @param st standby time
       @return True if successful
       @note The periodic measurement interval is calculated by this value,
       oversampling, and filter settings
       @warning During periodic detection runs, an error is returned
     */
-    bool setStandbyTime(const qmp6988::StandbyTime st);
+    bool writeStandbyTime(const qmp6988::StandbyTime st);
     ///@}
 
     /*! @brief Software reset */
@@ -409,9 +409,9 @@ class UnitQMP6988 : public Component, public PeriodicMeasurementAdapter<UnitQMP6
 
     bool read_calibration(qmp6988::Calibration& c);
     bool read_measurement_condition(uint8_t& cond);
-    bool set_measurement_condition(const uint8_t cond);
+    bool write_measurement_condition(const uint8_t cond);
     bool read_io_setup(uint8_t& s);
-    bool set_io_setup(const uint8_t s);
+    bool write_io_setup(const uint8_t s);
     bool read_measurement(qmp6988::Data& d);
     bool wait_measurement(const uint32_t timeout = 1000);
     bool is_ready_data();
diff --git a/src/unit/unit_SCD40.cpp b/src/unit/unit_SCD40.cpp
index 82fc253..75091c1 100644
--- a/src/unit/unit_SCD40.cpp
+++ b/src/unit/unit_SCD40.cpp
@@ -34,8 +34,8 @@ constexpr uint16_t mode_reg_table[] = {
 };
 
 constexpr uint32_t interval_table[] = {
-    5000U,
-    30 * 1000U,
+    5000U,       // 5 Sec.
+    30 * 1000U,  // 30 Sec.
 };
 
 }  // namespace
@@ -83,8 +83,8 @@ bool UnitSCD40::begin() {
         return false;
     }
 
-    if (!setAutomaticSelfCalibrationEnabled(_cfg.calibration)) {
-        M5_LIB_LOGE("Failed to set calibration");
+    if (!writeAutomaticSelfCalibrationEnabled(_cfg.calibration)) {
+        M5_LIB_LOGE("Failed to write automatic calibration");
         return false;
     }
 
@@ -129,7 +129,7 @@ bool UnitSCD40::stop_periodic_measurement(const uint32_t duration) {
     return false;
 }
 
-bool UnitSCD40::setTemperatureOffset(const float offset, const uint32_t duration) {
+bool UnitSCD40::writeTemperatureOffset(const float offset, const uint32_t duration) {
     if (inPeriodic()) {
         M5_LIB_LOGD("Periodic measurements are running");
         return false;
@@ -162,7 +162,7 @@ bool UnitSCD40::readTemperatureOffset(float& offset) {
     return ret;
 }
 
-bool UnitSCD40::setSensorAltitude(const uint16_t altitude, const uint32_t duration) {
+bool UnitSCD40::writeSensorAltitude(const uint16_t altitude, const uint32_t duration) {
     if (inPeriodic()) {
         M5_LIB_LOGD("Periodic measurements are running");
         return false;
@@ -187,7 +187,7 @@ bool UnitSCD40::readSensorAltitude(uint16_t& altitude) {
     return readRegister16(GET_SENSOR_ALTITUDE, altitude, GET_SENSOR_ALTITUDE_DURATION);
 }
 
-bool UnitSCD40::setAmbientPressure(const float pressure, const uint32_t duration) {
+bool UnitSCD40::writeAmbientPressure(const float pressure, const uint32_t duration) {
     if (pressure < 0.0f || pressure > 65535.f * 100) {
         M5_LIB_LOGE("pressure is not a valid scope %f", pressure);
         return false;
@@ -238,7 +238,7 @@ bool UnitSCD40::performForcedRecalibration(const uint16_t concentration, int16_t
     return false;
 }
 
-bool UnitSCD40::setAutomaticSelfCalibrationEnabled(const bool enabled, const uint32_t duration) {
+bool UnitSCD40::writeAutomaticSelfCalibrationEnabled(const bool enabled, const uint32_t duration) {
     if (inPeriodic()) {
         M5_LIB_LOGD("Periodic measurements are running");
         return false;
@@ -272,7 +272,7 @@ bool UnitSCD40::read_data_ready_status() {
     return readRegister16(GET_DATA_READY_STATUS, res, GET_DATA_READY_STATUS_DURATION) ? (res & 0x07FF) != 0 : false;
 }
 
-bool UnitSCD40::persistSettings(const uint32_t duration) {
+bool UnitSCD40::writePersistSettings(const uint32_t duration) {
     if (inPeriodic()) {
         M5_LIB_LOGD("Periodic measurements are running");
         return false;
diff --git a/src/unit/unit_SCD40.hpp b/src/unit/unit_SCD40.hpp
index c3b8fc8..254ca80 100644
--- a/src/unit/unit_SCD40.hpp
+++ b/src/unit/unit_SCD40.hpp
@@ -101,16 +101,15 @@ class UnitSCD40 : public Component, public PeriodicMeasurementAdapter<UnitSCD40,
     ///@name On-Chip Output Signal Compensation
     ///@{
     /*!
-      @brief Set the temperature offset
+      @brief Write the temperature offset
       @details Define how warm the sensor is compared to ambient, so RH and T
-      are temperature compensated. Has no effect on the CO2 reading Default
-      offsetis 4C
+      are temperature compensated. Has no effect on the CO2 reading Default offsetis 4C
       @param offset (0 <= offset < 175)
       @param duration Max command duration(ms)
       @return True if successful
       @warning During periodic detection runs, an error is returned
     */
-    bool setTemperatureOffset(const float offset, const uint32_t duration = scd4x::SET_TEMPERATURE_OFFSET_DURATION);
+    bool writeTemperatureOffset(const float offset, const uint32_t duration = scd4x::SET_TEMPERATURE_OFFSET_DURATION);
     /*!
       @brief Read the temperature offset
       @param[out] offset Offset value
@@ -120,15 +119,15 @@ class UnitSCD40 : public Component, public PeriodicMeasurementAdapter<UnitSCD40,
     */
     bool readTemperatureOffset(float &offset);
     /*!
-      @brief Set the sensor altitude
-      @details Define the sensor altitude in metres above sea level, so RH and
-      CO2 arecompensated for atmospheric pressure Default altitude is 0m
+      @brief Write the sensor altitude
+      @details Define the sensor altitude in metres above sea level, so RH and CO2 arecompensated for atmospheric
+      pressure Default altitude is 0m
       @param altitude Unit:metres
       @param duration Max command duration(ms)
       @return True if successful
       @warning During periodic detection runs, an error is returned
     */
-    bool setSensorAltitude(const uint16_t altitude, const uint32_t duration = scd4x::SET_SENSOR_ALTITUDE_DURATION);
+    bool writeSensorAltitude(const uint16_t altitude, const uint32_t duration = scd4x::SET_SENSOR_ALTITUDE_DURATION);
     /*!
       @brief Read the sensor altitude
       @param[out] altitude Altitude value
@@ -138,15 +137,14 @@ class UnitSCD40 : public Component, public PeriodicMeasurementAdapter<UnitSCD40,
     */
     bool readSensorAltitude(uint16_t &altitude);
     /*!
-      @brief Set the ambient pressure
-      @details Define the ambient pressure in Pascals, so RH and CO2 are
-      compensated for atmospheric pressure setAmbientPressure overrides
-      setSensorAltitude
+      @brief Write the ambient pressure
+      @details Define the ambient pressure in Pascals, so RH and CO2 are compensated for atmospheric pressure
+      setAmbientPressure overrides setSensorAltitude
       @param presure Unit: pascals (>= 0.0f)
       @param duration Max command duration(ms)
       @return True if successful
     */
-    bool setAmbientPressure(const float pressure, const uint32_t duration = scd4x::SET_AMBIENT_PRESSURE_DURATION);
+    bool writeAmbientPressure(const float pressure, const uint32_t duration = scd4x::SET_AMBIENT_PRESSURE_DURATION);
     ///@}
 
     ///@name Field Calibration
@@ -166,7 +164,7 @@ class UnitSCD40 : public Component, public PeriodicMeasurementAdapter<UnitSCD40,
       @return True if successful
       @warning During periodic detection runs, an error is returned
     */
-    bool setAutomaticSelfCalibrationEnabled(
+    bool writeAutomaticSelfCalibrationEnabled(
         const bool enabled = true, const uint32_t duration = scd4x::SET_AUTOMATIC_SELF_CALIBRATION_ENABLED_DURATION);
     /*!
       @brief Check if automatic self calibration is enabled
@@ -181,11 +179,11 @@ class UnitSCD40 : public Component, public PeriodicMeasurementAdapter<UnitSCD40,
     ///@name Advanced Features
     ///@{
     /*!
-      @brief Copy sensor settings from RAM to EEPROM
+      @brief Write sensor settings from RAM to EEPROM
       @return True if successful
       @warning During periodic detection runs, an error is returned
     */
-    bool persistSettings(const uint32_t duration = scd4x::PERSIST_SETTINGS_DURATION);
+    bool writePersistSettings(const uint32_t duration = scd4x::PERSIST_SETTINGS_DURATION);
     /*!
       @brief Read the serial number string
       @param[out] serialNumber Output buffer
diff --git a/src/unit/unit_SHT30.cpp b/src/unit/unit_SHT30.cpp
index 09895e8..191b3a7 100644
--- a/src/unit/unit_SHT30.cpp
+++ b/src/unit/unit_SHT30.cpp
@@ -193,7 +193,7 @@ bool UnitSHT30::stop_periodic_measurement() {
     return false;
 }
 
-bool UnitSHT30::accelerateResponseTime() {
+bool UnitSHT30::writeModeAccelerateResponseTime() {
     if (!inPeriodic()) {
         M5_LIB_LOGD("Periodic measurements are NOT running");
         return false;
diff --git a/src/unit/unit_SHT30.hpp b/src/unit/unit_SHT30.hpp
index f1065f0..6e08262 100644
--- a/src/unit/unit_SHT30.hpp
+++ b/src/unit/unit_SHT30.hpp
@@ -180,13 +180,12 @@ class UnitSHT30 : public Component, public PeriodicMeasurementAdapter<UnitSHT30,
     ///@}
 
     /*!
-      @brief set ART mode
-      @details After issuing the ART command the sensor will start acquiring
-      data with a frequency of 4Hz.
+      @brief Write the mode to ART
+      @details After issuing the ART command the sensor will start acquiring data with a frequency of 4Hz
       @return True if successful
-      @warning Only available during periodic measurements.
+      @warning Only available during periodic measurements
     */
-    bool accelerateResponseTime();
+    bool writeModeAccelerateResponseTime();
 
     ///@name Reset
     ///@{
@@ -201,8 +200,7 @@ class UnitSHT30 : public Component, public PeriodicMeasurementAdapter<UnitSHT30,
     /*!
       @brief General reset
       @details Reset using I2C general call
-      @waning This is a reset by General command, the command is also sent to
-      all devices with I2C connections
+      @waning This is a reset by General command, the command is also sent to all devices with I2C connections
       @return True if successful
      */
     bool generalReset();
@@ -238,7 +236,7 @@ class UnitSHT30 : public Component, public PeriodicMeasurementAdapter<UnitSHT30,
     bool clearStatus();
     ///@}
 
-    ///@name Serial
+    ///@name Serial number
     ///@{
     /*!
       @brief Read the serial number value
diff --git a/test/embedded/test_bme688/bme688_test.cpp b/test/embedded/test_bme688/bme688_test.cpp
index 8d89da0..2ff6f21 100644
--- a/test/embedded/test_bme688/bme688_test.cpp
+++ b/test/embedded/test_bme688/bme688_test.cpp
@@ -10,6 +10,7 @@
 #include <Wire.h>
 #include <M5Unified.h>
 #include <M5UnitUnified.hpp>
+#include <googletest/test_helper.hpp>
 #include <googletest/test_template.hpp>
 #include <unit/unit_BME688.hpp>
 #include <chrono>
@@ -81,6 +82,14 @@ constexpr uint8_t bsec_config[] = {
 
 std::random_device rng;
 
+void check_measurement_values(UnitBME688* u) {
+    EXPECT_TRUE(std::isfinite(u->temperature()));
+    EXPECT_TRUE(std::isfinite(u->pressure()));
+    EXPECT_TRUE(std::isfinite(u->humidity()));
+    EXPECT_TRUE(std::isfinite(u->resistance()));
+    // M5_LOGI("%f/%f/%f/%f", u->temperature(), u->pressure(), u->humidity(), u->resistance());
+}
+
 }  // namespace
 
 TEST_P(TestBME688, Settings) {
@@ -97,25 +106,25 @@ TEST_P(TestBME688, Settings) {
     const bme68xConf prev = unit->tphSetting();
 
     for (auto&& e : os_table) {
-        EXPECT_TRUE(unit->setOversamplingTemperature(e));
+        EXPECT_TRUE(unit->writeOversamplingTemperature(e));
         EXPECT_EQ(unit->tphSetting().os_temp, m5::stl::to_underlying(e));
         EXPECT_TRUE(unit->readOversamplingTemperature(os));
         EXPECT_EQ(os, e);
     }
     for (auto&& e : os_table) {
-        EXPECT_TRUE(unit->setOversamplingPressure(e));
+        EXPECT_TRUE(unit->writeOversamplingPressure(e));
         EXPECT_EQ(unit->tphSetting().os_pres, m5::stl::to_underlying(e));
         EXPECT_TRUE(unit->readOversamplingPressure(os));
         EXPECT_EQ(os, e);
     }
     for (auto&& e : os_table) {
-        EXPECT_TRUE(unit->setOversamplingHumidity(e));
+        EXPECT_TRUE(unit->writeOversamplingHumidity(e));
         EXPECT_EQ(unit->tphSetting().os_hum, m5::stl::to_underlying(e));
         EXPECT_TRUE(unit->readOversamplingHumidity(os));
         EXPECT_EQ(os, e);
     }
     for (auto&& e : filter_table) {
-        EXPECT_TRUE(unit->setIIRFilter(e));
+        EXPECT_TRUE(unit->writeIIRFilter(e));
         EXPECT_EQ(unit->tphSetting().filter, m5::stl::to_underlying(e));
         EXPECT_TRUE(unit->readIIRFilter(f));
         EXPECT_EQ(f, e);
@@ -132,7 +141,7 @@ TEST_P(TestBME688, Settings) {
         // M5_LOGW("%u/%u/%u/%u", tph.os_temp, tph.os_pres, tph.os_hum,
         //         tph.filter);
 
-        EXPECT_TRUE(unit->setTPHSetting(tph));
+        EXPECT_TRUE(unit->writeTPHSetting(tph));
         EXPECT_EQ(unit->tphSetting().os_temp, tph.os_temp);
         EXPECT_EQ(unit->tphSetting().os_pres, tph.os_pres);
         EXPECT_EQ(unit->tphSetting().os_hum, tph.os_hum);
@@ -143,7 +152,7 @@ TEST_P(TestBME688, Settings) {
             << tph.os_temp << "/" << tph.os_pres << "/" << tph.os_hum << "/" << tph.filter;
 
         EXPECT_TRUE(
-            unit->setOversampling((Oversampling)tph.os_temp, (Oversampling)tph.os_pres, (Oversampling)tph.os_hum));
+            unit->writeOversampling((Oversampling)tph.os_temp, (Oversampling)tph.os_pres, (Oversampling)tph.os_hum));
         EXPECT_EQ(unit->tphSetting().os_temp, tph.os_temp);
         EXPECT_EQ(unit->tphSetting().os_pres, tph.os_pres);
         EXPECT_EQ(unit->tphSetting().os_hum, tph.os_hum);
@@ -156,7 +165,7 @@ TEST_P(TestBME688, Settings) {
     // Calibration
     Calibration c0{}, c1{};
     EXPECT_TRUE(unit->readCalibration(c0));
-    EXPECT_TRUE(unit->setCalibration(c0));
+    EXPECT_TRUE(unit->writeCalibration(c0));
     EXPECT_TRUE(unit->readCalibration(c1));
     EXPECT_TRUE(memcmp(&c0, &c1, sizeof(c1)) == 0);
 
@@ -294,13 +303,13 @@ TEST_P(TestBME688, SingleShot) {
     tph.os_hum  = m5::stl::to_underlying(Oversampling::x16);
     tph.filter  = m5::stl::to_underlying(Filter::None);
     tph.odr     = m5::stl::to_underlying(ODR::None);
-    EXPECT_TRUE(unit->setTPHSetting(tph));
+    EXPECT_TRUE(unit->writeTPHSetting(tph));
 
-    bme68xHeatrConf hs{};
+    m5::unit::bme688::bme68xHeatrConf hs{};
     hs.enable     = true;
     hs.heatr_temp = 300;
     hs.heatr_dur  = 100;
-    EXPECT_TRUE(unit->setHeaterSetting(Mode::Forced, hs));
+    EXPECT_TRUE(unit->writeHeaterSetting(Mode::Forced, hs));
 
     bme68xData data{};
     EXPECT_TRUE(unit->measureSingleShot(data));
@@ -327,20 +336,23 @@ TEST_P(TestBME688, PeriodicForced) {
     tph.os_hum  = m5::stl::to_underlying(Oversampling::x16);
     tph.filter  = m5::stl::to_underlying(Filter::None);
     tph.odr     = m5::stl::to_underlying(ODR::None);
-    EXPECT_TRUE(unit->setTPHSetting(tph));
+    EXPECT_TRUE(unit->writeTPHSetting(tph));
 
-    bme68xHeatrConf hs{};
+    m5::unit::bme688::bme68xHeatrConf hs{};
     hs.enable     = true;
     hs.heatr_temp = 300;
     hs.heatr_dur  = 100;
-    EXPECT_TRUE(unit->setHeaterSetting(Mode::Forced, hs));
+    EXPECT_TRUE(unit->writeHeaterSetting(Mode::Forced, hs));
 
     //
     EXPECT_FALSE(unit->inPeriodic());
     EXPECT_TRUE(unit->startPeriodicMeasurement(Mode::Forced));
     EXPECT_TRUE(unit->inPeriodic());
     EXPECT_EQ(unit->mode(), Mode::Forced);
+    // Always wait for an interval to obtain the correct value for the first measurement
+    // EXPECT_EQ(unit->updatedMillis(), 0); //
 
+#if 0
     auto interval = unit->interval();
     // M5_LOGW("interval:%lu", interval);
     uint32_t cnt{8};
@@ -354,7 +366,7 @@ TEST_P(TestBME688, PeriodicForced) {
             auto duration = um - prev;
             prev          = um;
             EXPECT_LE(duration, interval);
-            M5_LOGI("%f/%f/%f/%f", unit->temperature(), unit->pressure(), unit->humidity(), unit->resistance());
+            //M5_LOGI("%f/%f/%f/%f", unit->temperature(), unit->pressure(), unit->humidity(), unit->resistance());
             EXPECT_TRUE(std::isfinite(unit->temperature()));
             EXPECT_TRUE(std::isfinite(unit->pressure()));
             EXPECT_TRUE(std::isfinite(unit->humidity()));
@@ -363,7 +375,9 @@ TEST_P(TestBME688, PeriodicForced) {
         m5::utility::delay(1);
     }
     EXPECT_EQ(cnt, 0U);
-
+#else
+    test_periodic_measurement(unit.get(), 8, 8, (unit->interval() * 2) * 8, check_measurement_values, false);
+#endif
     EXPECT_TRUE(unit->stopPeriodicMeasurement());
     EXPECT_FALSE(unit->inPeriodic());
     EXPECT_EQ(unit->mode(), Mode::Sleep);
@@ -382,15 +396,15 @@ TEST_P(TestBME688, PeriodicParallel) {
     tph.os_hum  = m5::stl::to_underlying(Oversampling::x16);
     tph.filter  = m5::stl::to_underlying(Filter::None);
     tph.odr     = m5::stl::to_underlying(ODR::None);
-    EXPECT_TRUE(unit->setTPHSetting(tph));
+    EXPECT_TRUE(unit->writeTPHSetting(tph));
 
-    bme68xHeatrConf hs{};
+    m5::unit::bme688::bme68xHeatrConf hs{};
     hs.enable = true;
     memcpy(hs.temp_prof, temp_prof, sizeof(temp_prof));
     memcpy(hs.dur_prof, mul_prof, sizeof(mul_prof));
     hs.shared_heatr_dur = (uint16_t)(140 - (unit->calculateMeasurementInterval(Mode::Parallel, tph) / 1000));
     hs.profile_len      = 10;
-    EXPECT_TRUE(unit->setHeaterSetting(Mode::Parallel, hs));
+    EXPECT_TRUE(unit->writeHeaterSetting(Mode::Parallel, hs));
 
     //
     EXPECT_FALSE(unit->inPeriodic());
@@ -398,6 +412,7 @@ TEST_P(TestBME688, PeriodicParallel) {
     EXPECT_TRUE(unit->inPeriodic());
     EXPECT_EQ(unit->mode(), Mode::Parallel);
 
+#if 0
     auto interval = unit->interval();
     uint32_t cnt{8};
     auto prev       = unit->updatedMillis();
@@ -427,7 +442,10 @@ TEST_P(TestBME688, PeriodicParallel) {
         m5::utility::delay(1);
     }
     EXPECT_EQ(cnt, 0U);
-
+#else
+    // TODO : What are the measurement intervals in the parallel mode datasheet?
+    test_periodic_measurement(unit.get(), 8, 1, (unit->interval() * 10) * 10, check_measurement_values, false);
+#endif
     EXPECT_TRUE(unit->stopPeriodicMeasurement());
     EXPECT_FALSE(unit->inPeriodic());
     EXPECT_EQ(unit->mode(), Mode::Sleep);
@@ -446,14 +464,14 @@ TEST_P(TestBME688, PeriodiSequential) {
     tph.os_hum  = m5::stl::to_underlying(Oversampling::x16);
     tph.filter  = m5::stl::to_underlying(Filter::None);
     tph.odr     = m5::stl::to_underlying(ODR::None);
-    EXPECT_TRUE(unit->setTPHSetting(tph));
+    EXPECT_TRUE(unit->writeTPHSetting(tph));
 
-    bme68xHeatrConf hs{};
+    m5::unit::bme688::bme68xHeatrConf hs{};
     hs.enable = true;
     memcpy(hs.temp_prof, temp_prof, sizeof(temp_prof));
     memcpy(hs.dur_prof, dur_prof, sizeof(dur_prof));
     hs.profile_len = 10;
-    EXPECT_TRUE(unit->setHeaterSetting(Mode::Sequential, hs));
+    EXPECT_TRUE(unit->writeHeaterSetting(Mode::Sequential, hs));
 
     //
     EXPECT_FALSE(unit->inPeriodic());
@@ -461,6 +479,7 @@ TEST_P(TestBME688, PeriodiSequential) {
     EXPECT_TRUE(unit->inPeriodic());
     EXPECT_EQ(unit->mode(), Mode::Sequential);
 
+#if 0
     auto interval = unit->interval();
     uint32_t cnt{8};
     auto prev       = unit->updatedMillis();
@@ -490,6 +509,9 @@ TEST_P(TestBME688, PeriodiSequential) {
         m5::utility::delay(1);
     }
     EXPECT_EQ(cnt, 0U);
+#else
+    test_periodic_measurement(unit.get(), 8, 1, (unit->interval() * 2) * 8, check_measurement_values, false);
+#endif
 
     EXPECT_TRUE(unit->stopPeriodicMeasurement());
     EXPECT_FALSE(unit->inPeriodic());
diff --git a/test/embedded/test_qmp6988/qmp6988_test.cpp b/test/embedded/test_qmp6988/qmp6988_test.cpp
index a7890c5..846931d 100644
--- a/test/embedded/test_qmp6988/qmp6988_test.cpp
+++ b/test/embedded/test_qmp6988/qmp6988_test.cpp
@@ -27,10 +27,10 @@ const ::testing::Environment* global_fixture = ::testing::AddGlobalTestEnvironme
 class TestQMP6988 : public ComponentTestBase<UnitQMP6988, bool> {
    protected:
     virtual UnitQMP6988* get_instance() override {
-        auto ptr        = new m5::unit::UnitQMP6988();
-        auto cfg        = ptr->config();
-        cfg.stored_size = 2;
-        ptr->config(cfg);
+        auto ptr         = new m5::unit::UnitQMP6988();
+        auto ccfg        = ptr->component_config();
+        ccfg.stored_size = 2;
+        ptr->component_config(ccfg);
         return ptr;
     }
     virtual bool is_using_hal() const override {
@@ -81,9 +81,9 @@ TEST_P(TestQMP6988, MeasurementCondition) {
             auto s = m5::utility::formatString("OS:%u/%u", ta, pa);
             SCOPED_TRACE(s);
 
-            EXPECT_FALSE(unit->setOversamplings(ta, pa));
-            EXPECT_FALSE(unit->setOversamplingTemperature(ta));
-            EXPECT_FALSE(unit->setOversamplingPressure(pa));
+            EXPECT_FALSE(unit->writeOversamplings(ta, pa));
+            EXPECT_FALSE(unit->writeOversamplingTemperature(ta));
+            EXPECT_FALSE(unit->writeOversamplingPressure(pa));
         }
     }
 
@@ -97,17 +97,17 @@ TEST_P(TestQMP6988, MeasurementCondition) {
             auto s = m5::utility::formatString("OS:%u/%u", ta, pa);
             SCOPED_TRACE(s);
 
-            EXPECT_TRUE(unit->setOversamplings(ta, pa));
+            EXPECT_TRUE(unit->writeOversamplings(ta, pa));
             EXPECT_TRUE(unit->readOversamplings(t, p));
             EXPECT_EQ(t, ta);
             EXPECT_EQ(p, pa);
 
-            EXPECT_TRUE(unit->setOversamplingTemperature(pa));
+            EXPECT_TRUE(unit->writeOversamplingTemperature(pa));
             EXPECT_TRUE(unit->readOversamplings(t, p));
             EXPECT_EQ(t, pa);
             EXPECT_EQ(p, pa);
 
-            EXPECT_TRUE(unit->setOversamplingPressure(ta));
+            EXPECT_TRUE(unit->writeOversamplingPressure(ta));
             EXPECT_TRUE(unit->readOversamplings(t, p));
             EXPECT_EQ(t, pa);
             EXPECT_EQ(p, ta);
@@ -120,13 +120,13 @@ TEST_P(TestQMP6988, IIRFilter) {
 
     // This process fails during periodic measurements.
     for (auto&& e : filter_table) {
-        EXPECT_FALSE(unit->setFilterCoeff(e));
+        EXPECT_FALSE(unit->writeFilterCoeff(e));
     }
 
     // Success if not in periodic measurement
     EXPECT_TRUE(unit->stopPeriodicMeasurement());
     for (auto&& e : filter_table) {
-        EXPECT_TRUE(unit->setFilterCoeff(e));
+        EXPECT_TRUE(unit->writeFilterCoeff(e));
 
         Filter f;
         EXPECT_TRUE(unit->readFilterCoeff(f));
@@ -146,17 +146,17 @@ TEST_P(TestQMP6988, UseCase) {
     Oversampling p;
 
     // This process fails during periodic measurements.
-    EXPECT_FALSE(unit->setWeathermonitoring());
-    EXPECT_FALSE(unit->setDropDetection());
-    EXPECT_FALSE(unit->setElevatorDetection());
-    EXPECT_FALSE(unit->setStairDetection());
-    EXPECT_FALSE(unit->setIndoorNavigation());
+    EXPECT_FALSE(unit->writeWeathermonitoringSetting());
+    EXPECT_FALSE(unit->writeDropDetectionSetting());
+    EXPECT_FALSE(unit->writeElevatorDetectionSetting());
+    EXPECT_FALSE(unit->writeStairDetectionSetting());
+    EXPECT_FALSE(unit->writeIndoorNavigationSetting());
 
     // Success if not in periodic measurement
     EXPECT_TRUE(unit->stopPeriodicMeasurement());
     {
         SCOPED_TRACE("Weather");
-        EXPECT_TRUE(unit->setWeathermonitoring());
+        EXPECT_TRUE(unit->writeWeathermonitoringSetting());
 
         EXPECT_TRUE(unit->readFilterCoeff(f));
         EXPECT_TRUE(unit->readOversamplings(t, p));
@@ -167,7 +167,7 @@ TEST_P(TestQMP6988, UseCase) {
 
     {
         SCOPED_TRACE("Drop");
-        EXPECT_TRUE(unit->setDropDetection());
+        EXPECT_TRUE(unit->writeDropDetectionSetting());
 
         EXPECT_TRUE(unit->readFilterCoeff(f));
         EXPECT_TRUE(unit->readOversamplings(t, p));
@@ -178,7 +178,7 @@ TEST_P(TestQMP6988, UseCase) {
 
     {
         SCOPED_TRACE("Elevator");
-        EXPECT_TRUE(unit->setElevatorDetection());
+        EXPECT_TRUE(unit->writeElevatorDetectionSetting());
 
         EXPECT_TRUE(unit->readFilterCoeff(f));
         EXPECT_TRUE(unit->readOversamplings(t, p));
@@ -189,7 +189,7 @@ TEST_P(TestQMP6988, UseCase) {
 
     {
         SCOPED_TRACE("Stair");
-        EXPECT_TRUE(unit->setStairDetection());
+        EXPECT_TRUE(unit->writeStairDetectionSetting());
 
         EXPECT_TRUE(unit->readFilterCoeff(f));
         EXPECT_TRUE(unit->readOversamplings(t, p));
@@ -200,7 +200,7 @@ TEST_P(TestQMP6988, UseCase) {
 
     {
         SCOPED_TRACE("Indoor");
-        EXPECT_TRUE(unit->setIndoorNavigation());
+        EXPECT_TRUE(unit->writeIndoorNavigationSetting());
 
         EXPECT_TRUE(unit->readFilterCoeff(f));
         EXPECT_TRUE(unit->readOversamplings(t, p));
@@ -215,13 +215,13 @@ TEST_P(TestQMP6988, Setup) {
 
     // This process fails during periodic measurements.
     for (auto&& e : standby_table) {
-        EXPECT_FALSE(unit->setStandbyTime(e));
+        EXPECT_FALSE(unit->writeStandbyTime(e));
     }
 
     // Success if not in periodic measurement
     EXPECT_TRUE(unit->stopPeriodicMeasurement());
     for (auto&& e : standby_table) {
-        EXPECT_TRUE(unit->setStandbyTime(e));
+        EXPECT_TRUE(unit->writeStandbyTime(e));
 
         StandbyTime st;
         EXPECT_TRUE(unit->readStandbyTime(st));
@@ -247,7 +247,7 @@ TEST_P(TestQMP6988, SingleShot) {
     EXPECT_FALSE(unit->inPeriodic());
 
     // Standby time for periodic measurement does not affect single shots
-    EXPECT_TRUE(unit->setStandbyTime(StandbyTime::Time4sec));
+    EXPECT_TRUE(unit->writeStandbyTime(StandbyTime::Time4sec));
 
     for (auto&& ta : os_table) {
         for (auto&& pa : os_table) {
@@ -304,7 +304,7 @@ TEST_P(TestQMP6988, Periodic) {
                     EXPECT_TRUE(unit->inPeriodic());
                     EXPECT_EQ(unit->updatedMillis(), 0);
 
-                    test_periodic_measurement(unit.get(), 4, check_measurement_values);
+                    test_periodic_measurement(unit.get(), 4, 1, check_measurement_values);
 
                     EXPECT_TRUE(unit->stopPeriodicMeasurement());
                     EXPECT_FALSE(unit->inPeriodic());
@@ -363,10 +363,10 @@ TEST_P(TestQMP6988, Periodic) {
         EXPECT_EQ(unit->updatedMillis(), 0);
 
 #if 1
-        test_periodic_measurement(unit.get(), 4, check_measurement_values);
+        test_periodic_measurement(unit.get(), 4, 1, check_measurement_values);
 
 #else
-        auto avg = test_periodic_measurement(unit.get(), idx == 0 ? 100 : 10, check_measurement_values);
+        auto avg = test_periodic_measurement(unit.get(), idx == 0 ? 100 : 10, 1, check_measurement_values);
         M5_LOGW("%s>I:%lu A:%u", s.c_str(), unit->interval(), avg);
 #endif
 
diff --git a/test/embedded/test_scd40/scd40_test.cpp b/test/embedded/test_scd40/scd40_test.cpp
index ee2a8b9..ff9f1ba 100644
--- a/test/embedded/test_scd40/scd40_test.cpp
+++ b/test/embedded/test_scd40/scd40_test.cpp
@@ -34,9 +34,12 @@ class TestSCD40 : public ComponentTestBase<UnitSCD40, bool> {
         auto ptr = new m5::unit::UnitSCD40();
 #endif
         if (ptr) {
+            auto ccfg        = ptr->component_config();
+            ccfg.stored_size = 3;
+            ptr->component_config(ccfg);
+
             auto cfg           = ptr->config();
             cfg.start_periodic = false;
-            cfg.stored_size    = 2;
             ptr->config(cfg);
         }
         return ptr;
@@ -81,10 +84,11 @@ constexpr uint16_t float_to_uint16(const float f) {
 struct ModeParams {
     const char* s;
     Mode mode;
+    uint32_t tolerance;
 };
 constexpr ModeParams mode_table[] = {
-    {"Normal", Mode::Normal},
-    {"LowPower", Mode::LowPower},
+    //    {"Normal", Mode::Normal, 1},
+    {"LowPower", Mode::LowPower, 500},
 };
 
 void check_measurement_values(UnitSCD40* u) {
@@ -93,7 +97,6 @@ void check_measurement_values(UnitSCD40* u) {
     EXPECT_TRUE(std::isfinite(u->latest().fahrenheit()));
     EXPECT_TRUE(std::isfinite(u->latest().humidity()));
 }
-
 }  // namespace
 
 TEST_P(TestSCD40, BasicCommand) {
@@ -114,24 +117,24 @@ TEST_P(TestSCD40, BasicCommand) {
 
         // These APIs result in an error during periodic detection
         {
-            EXPECT_FALSE(unit->setTemperatureOffset(0));
+            EXPECT_FALSE(unit->writeTemperatureOffset(0));
             float offset{};
             EXPECT_FALSE(unit->readTemperatureOffset(offset));
 
-            EXPECT_FALSE(unit->setSensorAltitude(0));
+            EXPECT_FALSE(unit->writeSensorAltitude(0));
             uint16_t altitude{};
             EXPECT_FALSE(unit->readSensorAltitude(altitude));
 
             int16_t correction{};
             EXPECT_FALSE(unit->performForcedRecalibration(0, correction));
 
-            EXPECT_FALSE(unit->setAutomaticSelfCalibrationEnabled(true));
+            EXPECT_FALSE(unit->writeAutomaticSelfCalibrationEnabled(true));
             bool enabled{};
             EXPECT_FALSE(unit->readAutomaticSelfCalibrationEnabled(enabled));
 
             EXPECT_FALSE(unit->startLowPowerPeriodicMeasurement());
 
-            EXPECT_FALSE(unit->persistSettings());
+            EXPECT_FALSE(unit->writePersistSettings());
 
             uint64_t sno{};
             EXPECT_FALSE(unit->readSerialNumber(sno));
@@ -144,7 +147,7 @@ TEST_P(TestSCD40, BasicCommand) {
             EXPECT_FALSE(unit->reInit());
         }
         // These APIs can be used during periodic detection
-        EXPECT_TRUE(unit->setAmbientPressure(0.0f));
+        EXPECT_TRUE(unit->writeAmbientPressure(0.0f));
     }
 }
 
@@ -167,10 +170,10 @@ TEST_P(TestSCD40, Periodic) {
         EXPECT_TRUE(unit->startPeriodicMeasurement(m.mode));
         EXPECT_TRUE(unit->inPeriodic());
         EXPECT_EQ(unit->updatedMillis(), 0);
-        test_periodic_measurement(unit.get(), 2, check_measurement_values);
+        test_periodic_measurement(unit.get(), 3, m.tolerance, check_measurement_values);
         EXPECT_TRUE(unit->stopPeriodicMeasurement());
 
-        EXPECT_EQ(unit->available(), 2);
+        EXPECT_EQ(unit->available(), 3);
         EXPECT_FALSE(unit->empty());
         EXPECT_TRUE(unit->full());
 
@@ -227,7 +230,7 @@ TEST_P(TestSCD40, OnChipOutputSignalCompensation) {
 
     {
         constexpr float OFFSET{1.234f};
-        EXPECT_TRUE(unit->setTemperatureOffset(OFFSET));
+        EXPECT_TRUE(unit->writeTemperatureOffset(OFFSET));
         float offset{};
         EXPECT_TRUE(unit->readTemperatureOffset(offset));
         EXPECT_EQ(float_to_uint16(offset), float_to_uint16(OFFSET)) << "offset:" << offset << " OFFSET:" << OFFSET;
@@ -235,7 +238,7 @@ TEST_P(TestSCD40, OnChipOutputSignalCompensation) {
 
     {
         constexpr uint16_t ALTITUDE{3776};
-        EXPECT_TRUE(unit->setSensorAltitude(ALTITUDE));
+        EXPECT_TRUE(unit->writeSensorAltitude(ALTITUDE));
         uint16_t altitude{};
         EXPECT_TRUE(unit->readSensorAltitude(altitude));
         EXPECT_EQ(altitude, ALTITUDE);
@@ -251,12 +254,12 @@ TEST_P(TestSCD40, FieldCalibration) {
     }
 
     {
-        EXPECT_TRUE(unit->setAutomaticSelfCalibrationEnabled(false));
+        EXPECT_TRUE(unit->writeAutomaticSelfCalibrationEnabled(false));
         bool enabled{};
         EXPECT_TRUE(unit->readAutomaticSelfCalibrationEnabled(enabled));
         EXPECT_FALSE(enabled);
 
-        EXPECT_TRUE(unit->setAutomaticSelfCalibrationEnabled(true));
+        EXPECT_TRUE(unit->writeAutomaticSelfCalibrationEnabled(true));
         EXPECT_TRUE(unit->readAutomaticSelfCalibrationEnabled(enabled));
         EXPECT_TRUE(enabled);
     }
@@ -299,17 +302,17 @@ TEST_P(TestSCD40, AdvancedFeatures) {
 
     // Set
     constexpr float OFFSET{1.234f};
-    EXPECT_TRUE(unit->setTemperatureOffset(OFFSET));
+    EXPECT_TRUE(unit->writeTemperatureOffset(OFFSET));
     constexpr uint16_t ALTITUDE{3776};
-    EXPECT_TRUE(unit->setSensorAltitude(ALTITUDE));
-    EXPECT_TRUE(unit->setAutomaticSelfCalibrationEnabled(false));
+    EXPECT_TRUE(unit->writeSensorAltitude(ALTITUDE));
+    EXPECT_TRUE(unit->writeAutomaticSelfCalibrationEnabled(false));
 
-    EXPECT_TRUE(unit->persistSettings());  // Save EEPROM
+    EXPECT_TRUE(unit->writePersistSettings());  // Save EEPROM
 
     // Overwrite settings
-    EXPECT_TRUE(unit->setTemperatureOffset(OFFSET * 2));
-    EXPECT_TRUE(unit->setSensorAltitude(ALTITUDE * 2));
-    EXPECT_TRUE(unit->setAutomaticSelfCalibrationEnabled(true));
+    EXPECT_TRUE(unit->writeTemperatureOffset(OFFSET * 2));
+    EXPECT_TRUE(unit->writeSensorAltitude(ALTITUDE * 2));
+    EXPECT_TRUE(unit->writeAutomaticSelfCalibrationEnabled(true));
 
     float off{};
     uint16_t alt{};
diff --git a/test/embedded/test_sht30/sht30_test.cpp b/test/embedded/test_sht30/sht30_test.cpp
index 214206a..9f6df9a 100644
--- a/test/embedded/test_sht30/sht30_test.cpp
+++ b/test/embedded/test_sht30/sht30_test.cpp
@@ -23,18 +23,17 @@ using namespace m5::unit;
 using namespace m5::unit::sht30;
 using namespace m5::unit::sht30::command;
 
-#define STORED_SIZE (2)
+constexpr size_t STORED_SIZE{2};
 
 const ::testing::Environment* global_fixture = ::testing::AddGlobalTestEnvironment(new GlobalFixture<400000U>());
 
 class TestSHT30 : public ComponentTestBase<UnitSHT30, bool> {
    protected:
     virtual UnitSHT30* get_instance() override {
-        auto ptr = new m5::unit::UnitSHT30();
-        auto cfg = ptr->config();
-        // cfg.start_periodic = false;
-        cfg.stored_size = STORED_SIZE;
-        ptr->config(cfg);
+        auto ptr         = new m5::unit::UnitSHT30();
+        auto ccfg        = ptr->component_config();
+        ccfg.stored_size = STORED_SIZE;
+        ptr->component_config(ccfg);
         return ptr;
     }
     virtual bool is_using_hal() const override {
@@ -138,7 +137,7 @@ TEST_P(TestSHT30, Periodic) {
             SCOPED_TRACE(s);
             EXPECT_FALSE(unit->measureSingleshot(d, rep, stretch));
         }
-        test_periodic_measurement(unit.get(), 4, check_measurement_values);
+        test_periodic_measurement(unit.get(), 4, 1, check_measurement_values);
         EXPECT_TRUE(unit->stopPeriodicMeasurement());
         EXPECT_FALSE(unit->inPeriodic());
 
@@ -169,12 +168,12 @@ TEST_P(TestSHT30, Periodic) {
 
     // ART Command (4 mps)
     EXPECT_FALSE(unit->inPeriodic());
-    EXPECT_FALSE(unit->accelerateResponseTime());
+    EXPECT_FALSE(unit->writeModeAccelerateResponseTime());
     EXPECT_TRUE(unit->startPeriodicMeasurement(MPS::Half,
                                                Repeatability::High));  // 0.5mps
     EXPECT_TRUE(unit->inPeriodic());
     EXPECT_EQ(unit->updatedMillis(), 0);
-    EXPECT_TRUE(unit->accelerateResponseTime());  // boost to 4mps
+    EXPECT_TRUE(unit->writeModeAccelerateResponseTime());  // boost to 4mps
 
     // Cannot call all singleshot in periodic
     for (auto&& e : ss_table) {
@@ -188,7 +187,7 @@ TEST_P(TestSHT30, Periodic) {
         EXPECT_FALSE(unit->measureSingleshot(d, rep, stretch));
     }
 
-    test_periodic_measurement(unit.get(), 4, check_measurement_values);
+    test_periodic_measurement(unit.get(), 4, 1, check_measurement_values);
     EXPECT_TRUE(unit->stopPeriodicMeasurement());
     EXPECT_FALSE(unit->inPeriodic());