ozone_cp/APP/service/ozone_control_service.c

#include "ozone_control_service.h"

#include "../zes8p5066lib/systicket.h"
#include "frequency_sweep_service.h"
#include "state_machine.h"

/**
 * @brief
 *
 *  状态机:
 *            不工作 ------> 扫描频率 --扫描频率完成--> 工作
 *                                       ^                         |
 *                                       |---------切换等级---------|
 *
 *
 *            不工作 ----->  设备自检  --> 扫描频率 --扫描频率完成--> 工作
 *
 **/

typedef enum {
  kIdleState,
  kBeforeWorkingStateSweepFrequency,
  kWorkingState,
} StateId_t;

state_machine_state_t states[] = {
    [kIdleState] =
        {
            .name = "kIdleState",
            .stateId = kIdleState,
            .duration = 0,
        },
    [kBeforeWorkingStateSweepFrequency] =
        {
            .name = "kBeforeWorkingStateSweepFrequency",
            .stateId = kBeforeWorkingStateSweepFrequency,
            .duration = 0,
        },
    [kWorkingState] =  //
    {
        .name = "kWorkingState",
        .stateId = kWorkingState,
        .duration = 0,
    }
    //
};

state_machine_t statemachine = {
    .states = states,
    .nstate = sizeof(states) / sizeof(states[0]),
    .nowstate = &states[kIdleState],
    .process_event = NULL,
    .nextstate = NULL,
    .laststate = NULL,
};

typedef struct {
  float resonant_frequency;
} Context_t;
static Context_t context;
static float const_level1_expect_power;

static uint16_t get_resonant_frequency(uint16_t startfreq, uint16_t step, uint16_t endfreq) {
  /**
   * @brief
   */

  float minpower = 0;
  uint16_t retfreq = 0;
  bool inited = false;
  for (uint16_t freq = startfreq; freq <= endfreq; freq += step) {
    float power = frequency_sweep_get_power(freq);
    if (inited) {
      minpower = power;
      retfreq = freq;
      inited = false;
      continue;
    }

    if (power < minpower) {
      minpower = power;
      retfreq = freq;
    }
  }
  return retfreq;
}

static state_machine_state_t* processBeforeWorkingStateSweepFrequency(state_machine_t* machine, state_machine_state_t* nowstate, int event) {
  /**
   * @brief 扫频
   */
  if (event == ENTER_STATE) {
    frequency_sweep_start(20000, 100, 40000, 3000);
  } else if (event == TIME_EVENT) {
    if (frequency_sweep_is_done()) {
      context.resonant_frequency = get_resonant_frequency(25000, 100, 35000);
      printf("----------Summarize--------\n");
      printf("-resonant_frequency: %f\n", context.resonant_frequency);
      return &states[kWorkingState];
    }
  } else if (event == EXIT_STATE) {
    frequency_sweep_stop();
  }
}

static float mf_get_ozone_power() {
  float powersum = 0;
  for (size_t i = 0; i < 10; i++) {
    powersum += port_adc_get_ozone_generator_power();
  }
  return powersum / 10;
}

static state_machine_state_t* state_machine_process_event(state_machine_t* machine, state_machine_state_t* nowstate, int event) {
  if /*  */ (nowstate == &states[kIdleState]) {
  } else if (nowstate == &states[kBeforeWorkingStateSweepFrequency]) {
    processBeforeWorkingStateSweepFrequency(machine, nowstate, event);
  } else if (nowstate == &states[kWorkingState]) {
    if (event == ENTER_STATE) {
      /**
       * @brief 在谐振点启动，此时臭氧功率最小
       */
      port_ozone_pwm_set_duty(context.resonant_frequency, 5000);
      port_ozone_pwm_start();
    } else if (event == TIME_EVENT) {
      /**
       * @brief 实时获取当前功率，并调整频率到指定功率
       */
      static uint32_t last_ticket = 0;
      if (systicket_haspassedms(last_ticket) > 10) {
        last_ticket = systicket_getms();
        float power = mf_get_ozone_power();
      }
    } else if (event == EXIT_STATE) {
      port_ozone_pwm_stop();
    }
  }
}

/**
 * @brief
 *  风扇加板子静态功率1.6W
 */