FluxSand Class Reference

Collaboration diagram for FluxSand:

Public Member Functions
	FluxSand (PWM *pwm_buzzer, Gpio *gpio_user_button_1, Gpio *gpio_user_button_2, CompGuiX *gui, Bmp280 *bmp280, Aht20 *aht20, Ads1115< 2 > *ads1115, AHRS *ahrs, InferenceEngine *inference)
void	Run ()
void	RunUnitTest ()

Private Member Functions
void	StartStopwatch ()
void	StopStopwatch ()
void	StartTimer (int duration_sec)
void	StopTimer ()

Private Attributes
PWM *	pwm_buzzer_
Gpio *	gpio_user_button_1_
Gpio *	gpio_user_button_2_
CompGuiX *	gui_
Bmp280 *	bmp280_
Aht20 *	aht20_
Ads1115< 2 > *	ads1115_
AHRS *	ahrs_
InferenceEngine *	inference_
ModeManager	mode_manager_
SensorManager	sensor_manager_
InferenceHandler	inference_handler_
InputHandler	input_handler_

Detailed Description

Definition at line 25 of file fluxsand.hpp.

Constructor & Destructor Documentation

FluxSand()

FluxSand::FluxSand ( PWM *  pwm_buzzer, Gpio *  gpio_user_button_1, Gpio *  gpio_user_button_2, CompGuiX *  gui, Bmp280 *  bmp280, Aht20 *  aht20, Ads1115< 2 > *  ads1115, AHRS *  ahrs, InferenceEngine *  inference  )

inline

Definition at line 29 of file fluxsand.hpp.

      : pwm_buzzer_(pwm_buzzer),
        gpio_user_button_1_(gpio_user_button_1),
        gpio_user_button_2_(gpio_user_button_2),
        gui_(gui),
        bmp280_(bmp280),
        aht20_(aht20),
        ads1115_(ads1115),
        ahrs_(ahrs),
        inference_(inference) {
    // Wait for system stabilization or hardware warm-up
    std::this_thread::sleep_for(std::chrono::milliseconds(6000));
 
    // Prepare the buzzer
    pwm_buzzer_->SetDutyCycle(0.0f);
    pwm_buzzer_->Enable();
 
    // Initialize sensor manager with sensor instances and GUI
    sensor_manager_.Init(ads1115_, aht20_, bmp280_, gui_);
 
    // Initialize inference handler with inference engine and mode manager
    // and bind timer control callbacks
    inference_handler_.Init(
        inference_, &mode_manager_, gui_, pwm_buzzer_,
        [this](int duration) { StartTimer(duration); },
        [this]() { StopTimer(); });
 
    // Initialize input handler with buttons and callbacks for stopwatch/timer
    input_handler_.Init(
        gpio_user_button_1_, gpio_user_button_2_, pwm_buzzer_, gui_,
        &mode_manager_,
        [this]() {
          if (mode_manager_.IsStopwatchRunning())
            StopStopwatch();
          else
            StartStopwatch();
        },
        [this]() { StopTimer(); });
  }

Member Function Documentation

Run()

void FluxSand::Run ( )

inline

Definition at line 72 of file fluxsand.hpp.

             {
    // Get current system time
    auto now = std::chrono::system_clock::now();
    std::time_t t = std::chrono::system_clock::to_time_t(now);
    std::tm* local_time = std::localtime(&t);
    int hour = local_time->tm_hour;
    int minute = local_time->tm_min;
 
    // Update GUI with the current tilt angle
    gui_->SetGravityDegree(ahrs_->eulr_.rol);
 
    // Get current UI mode and orientation
    auto mode = mode_manager_.GetMode();
    bool landscape = mode_manager_.IsLandscape();
 
    switch (mode) {
      case ModeManager::Mode::TIME:
        // Render clock in portrait or landscape orientation
        if (landscape)
          gui_->RenderTimeLandscape(hour, minute);
        else
          gui_->RenderTimePortrait(hour, minute);
        break;
 
      case ModeManager::Mode::HUMIDITY:
        // Display humidity reading
        gui_->RenderHumidity(
            static_cast<uint8_t>(sensor_manager_.GetHumidity()));
        break;
 
      case ModeManager::Mode::TEMPERATURE:
        // Display compensated temperature, offset for calibration
        gui_->RenderTemperature(static_cast<uint8_t>(
            sensor_manager_.GetCompensatedTemperature()));
        break;
 
      case ModeManager::Mode::STOPWATCH: {
        // Display stopwatch time with a 100-minute limit
        int64_t display_sec = mode_manager_.GetStopwatchSeconds();
        if (display_sec >= 100 * 60 - 1) display_sec = 100 * 60 - 1;
        gui_->RenderTimeLandscape(display_sec / 60, display_sec % 60);
        break;
      }
 
      case ModeManager::Mode::TIMER: {
        // Handle timer countdown and animation
        int64_t remaining = mode_manager_.GetRemainingTimerSeconds();
 
        // If timer finished, trigger buzzer and disable sand animation
        if (remaining == 0 && mode_manager_.IsTimerRunning()) {
          pwm_buzzer_->PlayNote(PWM::NoteName::C, 8, 1000);
          gui_->SandDisable();
          mode_manager_.StopTimer();
        }
 
        if (landscape) {
          // Show remaining time in landscape format
          gui_->RenderTimeLandscapeMS(remaining / 60, remaining % 60);
        } else if (mode_manager_.IsTimerRunning()) {
          // In portrait mode, animate sand flow
          gui_->SandEnable();
          int target_grid_down_count =
              128 - static_cast<int>(128.0f * static_cast<float>(remaining) /
                                     static_cast<float>(
                                         mode_manager_.GetMaxTimerDuration()));
          target_grid_down_count = std::clamp(target_grid_down_count, 0, 128);
 
          // Only move sand if more sand needs to fall
          if (target_grid_down_count > gui_->grid_down_.Count()) {
            SandGrid::MoveSand(&gui_->grid_up_, &gui_->grid_down_,
                               gui_->gravity_deg_);
          }
        } else {
          // If timer not running, show static time
          gui_->RenderTimePortraitMS(remaining / 60, remaining % 60);
        }
        break;
      }
 
      default:
        std::cout << "Unknown mode\n";
    }
 
    // Small delay to prevent high CPU usage
    std::this_thread::sleep_for(std::chrono::milliseconds(5));
  }

RunUnitTest()

void FluxSand::RunUnitTest ( )

inline

Definition at line 159 of file fluxsand.hpp.

                     {
    std::cout << "[FluxSand::UnitTest] Starting application unit test...\n";
 
    auto t0 = std::chrono::high_resolution_clock::now();
 
    // Simulate a full Run() frame for each mode
    for (int i = 0; i <= static_cast<int>(ModeManager::Mode::TIMER); ++i) {
      ModeManager::Mode mode = static_cast<ModeManager::Mode>(i);
      std::cout << std::format("  [Test] Simulating mode: {}\n", i);
 
      // Force mode and sub-states
      mode_manager_.SetMode(mode);
      switch (mode) {
        case ModeManager::Mode::STOPWATCH:
          mode_manager_.StartStopwatch();
          break;
        case ModeManager::Mode::TIMER:
          mode_manager_.StartTimer(30);  // 30s dummy countdown
          break;
        default:
          break;
      }
 
      auto start = std::chrono::high_resolution_clock::now();
      Run();  // Run one cycle
      auto end = std::chrono::high_resolution_clock::now();
      float elapsed =
          std::chrono::duration<float, std::milli>(end - start).count();
      std::cout << std::format("    → Run() completed in {:.2f} ms\n", elapsed);
    }
 
    auto t1 = std::chrono::high_resolution_clock::now();
    float total = std::chrono::duration<float, std::milli>(t1 - t0).count();
    std::cout << std::format(
        "[FluxSand::UnitTest] ✅ All modes tested in {:.2f} ms\n", total);
  }

StartStopwatch()

void FluxSand::StartStopwatch ( )

inlineprivate

Definition at line 198 of file fluxsand.hpp.

{ mode_manager_.StartStopwatch(); }

StartTimer()

void FluxSand::StartTimer ( int  duration_sec )

inlineprivate

Definition at line 202 of file fluxsand.hpp.

                                    {
    mode_manager_.StartTimer(duration_sec);
    gui_->Reset();
  }

StopStopwatch()

void FluxSand::StopStopwatch ( )

inlineprivate

Definition at line 199 of file fluxsand.hpp.

{ mode_manager_.StopStopwatch(); }

StopTimer()

void FluxSand::StopTimer ( )

inlineprivate

Definition at line 206 of file fluxsand.hpp.

{ mode_manager_.StopTimer(); }

Field Documentation

ads1115_

Ads1115<2>* FluxSand::ads1115_

private

Definition at line 215 of file fluxsand.hpp.

ahrs_

AHRS* FluxSand::ahrs_

private

Definition at line 216 of file fluxsand.hpp.

aht20_

Aht20* FluxSand::aht20_

private

Definition at line 214 of file fluxsand.hpp.

bmp280_

Bmp280* FluxSand::bmp280_

private

Definition at line 213 of file fluxsand.hpp.

gpio_user_button_1_

Gpio* FluxSand::gpio_user_button_1_

private

Definition at line 210 of file fluxsand.hpp.

gpio_user_button_2_

Gpio* FluxSand::gpio_user_button_2_

private

Definition at line 211 of file fluxsand.hpp.

gui_

CompGuiX* FluxSand::gui_

private

Definition at line 212 of file fluxsand.hpp.

inference_

InferenceEngine* FluxSand::inference_

private

Definition at line 217 of file fluxsand.hpp.

inference_handler_

InferenceHandler FluxSand::inference_handler_

private

Definition at line 222 of file fluxsand.hpp.

input_handler_

InputHandler FluxSand::input_handler_

private

Definition at line 223 of file fluxsand.hpp.

mode_manager_

ModeManager FluxSand::mode_manager_

private

Definition at line 220 of file fluxsand.hpp.

pwm_buzzer_

PWM* FluxSand::pwm_buzzer_

private

Definition at line 209 of file fluxsand.hpp.

sensor_manager_

SensorManager FluxSand::sensor_manager_

private

Definition at line 221 of file fluxsand.hpp.

---

The documentation for this class was generated from the following file:

• src/controller/fluxsand.hpp