ozone_cp/APP/main.c

#include <stdbool.h>  //定义布尔
#include <string.h>

#include "key.h"
#include "port.h"
#include "systicket.h"
#include "this_device.h"

static key_t s_keys[] = {
    s_key_init("powerkey", port_gpio_get_power_key_state),
    s_key_init("levelkey", port_gpio_get_level_key_state),
    s_key_init("timerkey", port_gpio_get_timer_key_state),
    s_key_init("intervalkey", port_gpio_get_interval_key_state),
};

static ThisDevice_t this_device;

static void mf_led_rgb_set(bool red, bool green, bool blue) {
  port_led_r_set(red);
  port_led_g_set(green);
  port_led_b_set(blue);
}

static void mf_init_all_subdevice_state() {
  port_debug_set(false);
  port_fan_set(false);
  port_led0_set(false);
  port_led1_set(false);
  port_led2_set(false);
  port_led3_set(false);
  port_led_r_set(false);
  port_led_g_set(false);
  port_led_b_set(false);
}

static void time_set_led_state(uint8_t led_num, bool state) {
  switch (led_num) {
    case 0:
      port_led0_set(false);
      port_led1_set(false);
      port_led2_set(false);
      port_led3_set(false);
      break;
    case 1:
      port_led0_set(state);
      port_led1_set(false);
      port_led2_set(false);
      port_led3_set(false);
      break;
    case 2:
      port_led0_set(state);
      port_led1_set(state);
      port_led2_set(false);
      port_led3_set(false);
      break;
    case 3:
      port_led0_set(state);
      port_led1_set(state);
      port_led2_set(state);
      port_led3_set(false);
      break;
    case 4:
      port_led0_set(state);
      port_led1_set(state);
      port_led2_set(state);
      port_led3_set(state);
      break;

    default:
      printf("no more led\n");
      break;
  }
}

//开始工作
static void startwork() { port_fan_set(true); }
//停止工作
static void stopwork() { port_fan_set(false); }

static void poweron() {
  this_device.power = true;
  this_device.ozone_level = level_low;
  this_device.ozone_module = normal;
  startwork();

  return;
}
static void powerdown() {
  this_device.power = false;
  stopwork();

  return;
}

// 各个按键处理逻辑
static void mf_process_poweron_key(key_t *key) {
  printf("key name:%s\n", key->name);

  if (!this_device.power) {
    mf_init_all_subdevice_state();
    poweron();
  } else {
    powerdown();
  }

  return;
}
static void mf_process_level_key(key_t *key) {
  if (!this_device.power) {
    mf_init_all_subdevice_state();
    return;
  }
  printf("key name:%s\n", key->name);

  if (this_device.ozone_level == level_high) {
    this_device.ozone_level = level_low;
  } else if (this_device.ozone_level == level_low) {
    this_device.ozone_level = level_high;
  }

  return;
}
static void mf_process_timer_key(key_t *key) {
  if (!this_device.power) {
    mf_init_all_subdevice_state();
    return;
  }
  printf("key name:%s\n", key->name);

  if (this_device.configuration_mode == false) {
    this_device.configuration_start_time = systicket_get_now_ms();
    this_device.configuration_mode = true;
  } else {
    this_device.time_led_num = this_device.time_led_num + 1;
    if (this_device.time_led_num > 4) {
      this_device.time_led_num = this_device.time_led_num - 4;
    }
  }

  return;
}
static void mf_process_interval_key(key_t *key) {
  if (!this_device.power) {
    mf_init_all_subdevice_state();
    return;
  }
  printf("key name:%s\n", key->name);
  return;
}

static void onkey(key_t *key, key_state_t key_state) {
  if /*  */ (strcmp(key->name, "powerkey") == 0 && zks_rising_edge == key_state) {
    mf_process_poweron_key(key);
  } else if (strcmp(key->name, "levelkey") == 0 && zks_rising_edge == key_state) {
    mf_process_level_key(key);
  } else if (strcmp(key->name, "timerkey") == 0 && zks_rising_edge == key_state) {
    mf_process_timer_key(key);
  } else if (strcmp(key->name, "intervalkey") == 0 && zks_rising_edge == key_state) {
    mf_process_interval_key(key);
  }
}

key_module_t key_module = key_module_init(s_keys, onkey);

//等级处理
void device_level_process() {
  if (this_device.ozone_level == level_low) {
    mf_led_rgb_set(true, false, false);
  } else if (this_device.ozone_level == level_high) {
    mf_led_rgb_set(false, false, true);
  }
}
//定时处理
void device_time_process() {}

void hcis_shcedule_process() {
  if (!this_device.power) {
    mf_init_all_subdevice_state();
    return;
  }

  device_level_process();
  device_time_process();
}

void hcis_shcedule() {
  static uint32_t ticket = 0;

  if (systicket_haspassedms(ticket) > 30) {
    ticket = systicket_get_now_ms();
    hcis_shcedule_process();
  }
}

void configuration_shcedule() {
  static bool led_state;
  static uint32_t led_ticket = 0;
  if (this_device.configuration_mode == true) {
    if (systicket_haspassedms(this_device.configuration_start_time) > 2000) {
      this_device.configuration_mode = false;
      time_set_led_state(this_device.time_led_num, true);
    }

    if (systicket_haspassedms(led_ticket) > 100) {
      led_ticket = systicket_get_now_ms();
      time_set_led_state(this_device.time_led_num, led_state);
      led_state = !led_state;
    }
  }
}

void hardware_init() {
  SystemInit();            //配置系统时钟
  DeviceClockAllEnable();  //打开所有外设时钟
  systicket_init();
  port_init();
}
void hardware_default_settings() { mf_init_all_subdevice_state(); }

void flip_debuf_light_level() {
  static uint8_t debug_led_state = 1;
  debug_led_state = !debug_led_state;
  port_debug_set(debug_led_state);
}

int main() {
  hardware_init();
  hardware_default_settings();

  key_init(&key_module);

  while (true) {
    // scan key
    DO_IT_EACH_MS(20) { key_do_loop_in_each_period(); };
    END();

    // debug light
    DO_IT_EACH_MS(200) { flip_debuf_light_level(); }
    END();

    hcis_shcedule();
    configuration_shcedule();
  }

  return 0;
}